26 Pemrograman Aplikasi Mobile - Putri - Telkom - Fix - Putri Elfa Mas'Udia

PEMROGRAMAN APLIKASI MOBILE
Putri Elfa Masùdia, S.T., M.Cs

Adzikirani, S.S.T., M.Tr.T
Dimas Rossiawan Hendra Putra, S.Kom., M.Tr.T.
PEMROGRAMAN APLIKASI MOBILE i

Pemrograman Aplikasi Mobile
Copyrights © 2022. All Rights Reserved
Hak cipta dilindungi undang-undang
Penulis:
Putri Elfa Masùdia, S.T., M.Cs
Adzikirani, S.S.T., M.Tr.T
Dimas Rossiawan Hendra Putra, S.Kom., M.Tr.T.
Penyunting:
Dhega Febiharsa
Desain & Tata Letak:

Tim Penerbit Cerdas Ulet Kreatif
ISBN :
Cetakan Pertama : 2022
Penerbit :
Cerdas Ulet Kreatif
Jl. Manggis 72 RT 03 RW 04 Jember Lor - Patrang
Jember - Jawa Timur 68118
Telp. 0331-4431347, 412387 Faks. 4431347
e-mail : info@cerdas.co.id
Distributor Tunggal:
Cerdas Ulet Kreatif
Jl. Manggis 72 RT 03 RW 04 Jember Lor - Patrang
Jember - Jawa Timur 68118
Telp. 0331-4431347, 412387 Faks. 4431347
e-mail : info@cerdas.co.id
Undang-Undang RI Nomor 19 Tahun 2002

Tentang Hak Cipta
Ketentuan Pidana
Pasal 72 (ayat 2)
Barang Siapa dengan sengaja menyiarkan, memamerkan,
mengedarkan, atau menjual kepada umum suatu ciptaan atau
barang hasil pelanggaran Hak Cipta atau hak terkait
sebagaimana dimaksud pada ayat (1), dipidana dengan pidana
penjara paling lama 5 (lima) tahun dan/atau denda paling
banyak Rp. 500.000.000,00 (lima ratus juta rupiah).
ii PEMROGRAMAN APLIKASI MOBILE

KATA PENGANTAR
Segala puji bagi Allah, Tuhan Yang Maha Esa atas rahmat dan
karunia-Nya, sehingga penulis dapat menyelesaikan buku ajar
dengan baik. Tak lupa juga kami mengucapkan shalawat serta salam
kepada Nabi Besar Muhammad SAW, karena berkat beliau, kita
mampu keluar dari kegelapan menuju jalan yang lebih terang.
Kami ucapkan juga terimakasih kepada pihak-pihak yang telah

mendukung lancarnya proses penulisan hingga proses cetak yaitu
orang tua kami, rekan rekan kami, penerbit, dan masih banyak lagi
yang tidak bisa kami sebutkan satu per satu
Penulisan buku ajar kami yang berjudul “Pemrograman

Aplikasi Mobile” ini relevan dengan matakulliah pemrograman aplikasi
mobil dengan harapan menjadi alternatif pegangan bagi mahasiswa
dan dosen yang menempuh matakuliah tersebut, semoga bermanfaat
untuk mempermudah mahasiswa dalam memahami materi.
Kami sadar, buku ini masih banyak luput dan kekeliruan yang
tentu saja jauh dari sempurna. Oleh sebab itu kami mohon agar
pembaca memberi kritik dan juga saran terhadap karya buku ini untuk
perbaikan. Semoga buku ini dapat bermanfaat bagi penulis dan
pembaca
Malang, 1 Juli 2022
PEMROGRAMAN APLIKASI MOBILE iii

RENCANA PEMBELAJARAN SEMESTER (RPS)
Politeknik Negeri Malang

K NEGERI
NI M
K
E
JURUSAN TEKNIK ELEKTRO

IT
LA
POL
NG
PROGRAM STUDI : TEKNIK TELEKOMUNIKASI
RENCANA PEMBELAJARAN SEMESTER (RPS)
MATA KULIAH KODE RUMPUN MATA BOBOT (sks) SEMESTER TGL. PENYUSUNAN
KULIAH
Pemrograman
Pemrograman Aplikasi RTT157006 Aplikasi Mobile 2 4 7 Februari 2021
Mobile
OTORISASI Dosen Pengembang RPS Koordinator RMK Ka PRODI
Putri Elfa Masùdia, ST.,M.Cs Hendro Darmono, M.Nanak Zakaria, ST., MT
B.Eng, M.T,
Capaian Pembelajaran Capaian Pembelajaran Lulusan Program Studi(CPL-
(CP) Prodi)
Mahasiswa mampu membangun aplikasi android sederhana menggunakan android studio yang
dapat dikoneksikan dengan database
iv PEMROGRAMAN APLIKASI MOBILE

Capaian Pembelajaran Lulusan yang dibebankan pada mata kuliah (CPL-MK)
Mahasiswa mampu memahami konsep dasar Teknologi Mobile

Mahasiswa mampu memahami perbedaan penggunaan layout pada android studio
Mahasiswa mampu membuat desain sederhana menggunakan komponen dasar GUI pada android
studio
Mahasiswa mampu membuat multiscreen menggunakan intent maupun fragment
Mahasiswa mampu mengaksese internal device dan mampu memasukkan google maps dan GPS
pada aplikasi android
Mahasiswa mampu mengkoneksikan aplikasi android menggunakan database
Diskripsi Singkat Mata Pada Matakuliah Pemrograman Aplikasi Mobile, mahasiswa dikenalkan dengan konsep dasar
Kuliah teknologi mobile, dan diberikan materi praktikum menggunakan android studio untuk bisa membuat
aplikasi android sederhana yang dapat dikoneksikan dengan database firebase maupun SQL Lite
Materi Pembelajaran / 1. Konsep Dasar Teknologi Mobile Internet, Arsitektur dan Struktur Android.
Pokok Bahasan 2. IDE: Lembar kerja dan Project Android
3. Layout (linier, relative, constrain)
4. Komponen Graphical User Interface (Button dengan onClickListener, Button dengan cara klasik,
Checkbox, Radio Button, Spinner)
5. Multi Screen. (Intent dan fragment)
6. Akses Google Maps, GPS
7. Akses Internal Device (Kamera, Accelerometer dll)
8. Database sederhana menggunakan Firebase
9. Database sederhana menggunakan Sql lite
Pustaka Utama :
1. Dimarzio, J.F. (2008). Android Programmer’s Guide. MC Graw Hill, New York Chicago San
PEMROGRAMAN APLIKASI MOBILE v

Francisco Lisbon London Madrid City.
2. Huang, Jim, (2011). Android Graphics. Oxlab Developer & Co-Founder.
3. Merier, Reto. (2009). Android Application development. Wiley Publishing, Inc. United States of
America.
4. Djunaedi, Feri, (2011). Menggunakan Database di Android.
Pendukung :
--
Media Pembelajaran Software : Hardware :
Android Studio Laptop/PCS
LCD
Whiteboard
Nama Dosen Pengampu Putri Elfa Masùdia, ST., M.Cs
Matakuliah Syarat Algoritma dan Pemgrograman
Min Kemampuan Bahan kajian Bentuk dan Estima Pengalaman Kriteria & Indikator Bob
ggu Akhir Yang (Materi Metode si Belajar Bentuk Penilaian ot
Ke Direncanakan Pembelajaran Pembelajar Waktu Mahasiswa Penilaian Penil
(Sub-CP-MK) ) an aian
(%)
(1) (2) (3) (4) (5) (6) (7) (8) (9)
1 1. Mengenal 1. Konsep 1. Ceramah 1x4x45’ 1. Mendengarka 1. Tanya jawab 1. Mampu 5%

tujuan mata dasar 2. Kuliah n penjelasan Multiple memahami
kuliah pemrogram online konsep dasar choice konsep dasar
2. Mengenal an 3. Diskusi teknologi 2. Praktek pemrograman
konsep berbasis menggun mobile membuat berbasis object
vi PEMROGRAMAN APLIKASI MOBILE

Pemrograman objek akan 2. Memahami class dan 2. Mampu
berbasis 2. Bahasa google konsep dasar object membuat Class
Objek Pemrogra meet pemrograman dan Object
3. Mengenal man Java berbasis objek
Java sebagai 3. Class
bahasa 4. Object
pemrograman
android studio
2 1. Mengenal 1. Konsep 1. Ceramah 1x4x45’ 1. Mendengarka 1. Praktek 1. Berhasil 5%
Konsep dasar dasar 2. Kuliah n penjelasan Menginstall menginstall
teknologi teknologi online konsep dasar Android Android studio
mobile Mobile 3. Diskusi teknologi Studio
Android 2. Cara menggun mobile
2. Menginstall meginstall akan 2. Memahami
Android Androis google konsep dasar
Studio dan Studio meet pemrograman
emulator 4. Praktek berbasis objek
Cara 3. Menginstall
Install Android studio
mandiri
3 1. Mahasiswa 1. Struktur 1. Ceramah 1x4x45 1. Mendengarka 1. Mampu 10%
mampu Folder 2. Kuliah ’ n penjelasan memahami
memahami Project online struktur 1. Tugas soal struktur android
struktur android Android 3. Video android studio studi kasus 2. Mampu
yang meliputi 2. Manifest, pembelaja 2. Studi kasus 2. Akltif diskusi membedakan
lembar kerja Java, Res ran mengenai online fungsi folder
dan project 3. Gradle 4. Praktikum aplikasi melalui LMS manifest, java
android mandiri mobile 3. Tanya jawab dan res
multiple
choice
PEMROGRAMAN APLIKASI MOBILE vii

melalui LMS
4 1. Mahasiswa 1. Activity 1. Ceramah 1x4x45 1. Mendengarka 1. Tanya 1. Ketepatan 5%
mampu 2. Siklus 2. Kuliah ’ n penjelasan jawab jawaban soal
memahami hidup online tentang multiple 2. Ketepatan
Activity dan Activity 3. Video Activity dan choice penjelasan
siklus hidup 3. Toast pembelajar siklus hidup 2. Praktek penyelesaian
Activity 4. Widget an Activity membuat soal
2. Mahasiswa (Edit Text, 4. Praktikum 2. Praktikum GUI 3. Mampu
mengenal TextView, mandiri membuat sederhana membuat
komponen Button, Activity program untuk
dasar (widget) Radio sederhana menampilkan
pada android Button) dan
studio memasukkan
data
5 1. Mahasiswa 1. Linier 1. Ceramah 1x4x45 1. Mendengarka 1. Tanya 1. Mampu 5%
mampu layout 2. Kuliah ’ n penjelasan jawab memahami
memahami 2. Relative online tentang multiple perbedaan
perbedaan linier layout 3. Video perbedaan choice ketiga layout
layout, relative 3. Constrain pembelajar liner, relative 2. Praktek 2. Mampu
layout, dan layout an dan constrain Membuat mengaplikasi
constrain layout 4. Praktikum layout program kan ketiga
2. Mahasiswa mandiri 2. Praktikum layout dalam
mampu mengaplikasika aplikasi
membuat n masing- android
aplikasi masing layout
menggunakan dengan
salah satu panduan
layout jobsheet
viii PEMROGRAMAN APLIKASI MOBILE

6-7 1. Mahasiswa 1. Implisit 1. Ceramah 2x4x45 1. Mendengarkan 1. Tanya 1. Ketepatan 10%
mampu Intent 2. Kuliah ’ ceramah jawab jawaban soal
memahami 2. Eksplisist Online tentang multiple 2. Ketepatan
macam-macam Intent 3. Praktikum penggunaan choice penjelasan
intent mandiri intent 2. Praktek penyelesaian
4. Latihan 2. Praktikum Membuat soal
soal membuat program 3. Mampu
5. Diskusi aplikasi android dengan membuat
Online sederhana menerapka program
menggunakan n implisit dengan
implisit intent intent dan menerapkan
dan eksplisit eksplisit implisit intent
intent intent dan eksplisit
intent
8 1. Mahasiswa 1. Put Extra 1. Ceramah 2x4x45 1. Mendengarkan 1. Tanya 1. Ketepatan 10%
mampu dan Bundle 2. Kuliah ’ ceramah jawab jawaban soal
memahami 2. Radio Online tentang multiple 2. Ketepatan
pengiriman data Button dan 3. Praktikum penggunaan choice penjelasan
menggunakan list View mandiri intent 2. Praktek penyelesaian
Put Extra dan 3. Dialog 4. Latihan 2. Praktikum Membuat soal
Bundle Message soal membuat program 3. Mampu
2. Mampu 5. Diskusi aplikasi android dengan membuat
menggunakan Online sederhana menerapka program
Radio Button menggunakan n implisit dengan
dan List View implisit intent intent dan menerapkan
3. Mampu dan eksplisit eksplisit implisit intent
PEMROGRAMAN APLIKASI MOBILE ix

membuat intent intent dan eksplisit
Dialog Message intent
9 UTS Semua LMS 1 x 2 x Mengerjakan Tanya jawab 1.
Materi dari 45 sola Multiple multiple choice
Minggu 1-8 Choice yang
disediakan
melalui LMS
10 1. Mahasiswa 1. Backstage 1. Kelas 2x6x45 1. Mendengarka 1. Tanya 1. Ketepatan 15%
mampu Fragment Online n ceramah jawab jawaban soal
memahami 2. Embedded 2. Video tentang multiple 2. Ketepatan
macam- Fragment pembelaja penggunaan choice penjelasan
macam ran fragment 2. Praktek penyelesaian
fragment 3. Studi 2. Praktikum Membuat soal
2. Mahasiswa Kasus membuat program 3. Mengetahui
mampu 4. Praktikum aplikasi dengan perbedaan
membuat mandiri android menerapka intent dengan
fragment 5. Latihan sederhana n backstage fragment
sederhana Soal menggunakan fragment 4. Mampu
6. Diskusi backstage dan membuat
fragment dan embedded program
embedded fragment dengan
fragment menerapkan
backstage
fragment dan
embedded
fragment
11 1. Mahasiswa 1.Langkah 1. Kuliah 1x4x45 1. Mendengarka 1. Tanya jawab 1. Ketepatan 5%
mampu langkah online ’ n ceramah multiple jawaban soal
x PEMROGRAMAN APLIKASI MOBILE

memahami untuk 2. Video tentang choice 2. Ketepatan
cara mendapatka pembelaja google Maps 2. Praktek penjelasan
pengaksesan n API Key ran 2. Praktikum mengintegras penyelesaian
google maps 2.Input Api 3. Studi membuat ikan google soal
dan GPS Key di Kasus aplikasi maps ke 3. Mampu
Android 4. Praktikum android dalam membuat API
Studio mandiri sederhana android key dan
3. Current 5. Latihan menggunakan mengintegrasik
Location Soal google maps an dengan
6. Diskusi android
12 1. Mahasiswa 1. Akses 1. Kelas 1x4x45 1. Mendengarka 1. Tanya jawab 1. Ketepatan 15%

mampu kamera Online n ceramah multiple jawaban soal
memahami cara 2. Akses 2. Video tentang cara choice 2. Ketepatan
pengaksesan Accelerator pembelaja akses ke 2. Praktek penjelasan
internal device ran internal device Membuat penyelesaian
3. Studi 2. Praktikum akses ke soal
kasus membuat imternal 3. Mampu
4. Praktikum akses ke device memahami cara
mandiri internal device pengaksesan
5. Diskusi ke internal
device
13- 1. Mahasiswa 1. Konsep 1. Kelas 1x4x45 1. Mendengarka 1. Tanya jawab 1. Ketepatan 5%
14 mampu dasar Online n ceramah multiple jawaban
memahami Firebase 2. Video tentang choice soal
konsep dasar 2. Fitur2 pembel firebase 2. Praktek 2. Ketepatan
Database firebase ajaran 2. Praktikum Membuat penjelasan
Firebase 3. Create 3. Studi membuat project penyelesai
PEMROGRAMAN APLIKASI MOBILE xi

project kasus project sederhana an soal
4. Praktiku sederhana mengguanak
m mengguankan an firebase
mandiri firebase
5. Diskusi
15 Mahasiswa 1. Pembuatan 1. Kelas 2x4x45 1. Mendengarka 1. Tanya jawab 1. Ketepatan 10%
mampu database Online n ceramah multiple jawaban soal
memahami 2. Koneksi 2. Video tentang SQL choice 2. Ketepatan
konsep dasar SQL Lite pembela Lite 2. Praktek penjelasan
Database dengan jaran 2. Praktikum Membuat penyelesaian
menggunakan android 3. Studi membuat database soal
SQL Lite kasus database dengan SQL
4. Praktiku sederhana lIte
m menggunakan
mandiri SQL Lite
5. Diskusi
16 Project 1. 1. 1. 1. 1.
xii PEMROGRAMAN APLIKASI MOBILE

DAFTAR ISI
KATA PENGANTAR ........................................................................................... iii
RENCANA PEMBELAJARAN SEMESTER (RPS) .......................................... iv
DAFTAR ISI ...................................................................................................... xiii
BAB 1 PENGENALAN JAVA DAN PEMROGRAMAN APLIKASI MOBILE1
Kenapa Android dan Java Dibutuhkan ........................................................... 1
A. Bagaimana Java dan Android Bekerja Sama ....................................... 2
B. API ANDROID ......................................................................................... 3
C. Java adalah Object-Oriented.................................................................. 3
D. Apakah Android itu Sebenarnya? .......................................................... 5
E. Android Studio ......................................................................................... 5
F. Seputar Tentang Bahasa Pemrograman Java ...................................... 6
BAB 2 INSTALASI ANDROID STUDIO ...................................................... 14
A. Pendahuluan .......................................................................................... 14
B. Instalasi Android Studio ......................................................................... 14
C. Membuat Project Sederhana di Android Studio ................................... 21
BAB 3 STRUKTUR PROJECT ANDROID .................................................. 28
A. Struktur Project ...................................................................................... 28
B. Cara Membuat Project .......................................................................... 28
C. Jendela Utama Android Studio ............................................................ 30
BAB 4 ACTIVITY .......................................................................................... 39
A. Activity .................................................................................................... 39
B. Activity Life Cycle (Daur Hidup Activity) .............................................. 39
C. Latihan ................................................................................................... 44
D. Cara Membuat Activity Sederhana ...................................................... 47
PEMROGRAMAN APLIKASI MOBILE xiii

BAB 5 LAYOUT ............................................................................................. 56
A. LAYOUT ................................................................................................. 56
B. LINEAR LAYOUT .................................................................................. 56
C. RELATIF LAYOUT ................................................................................ 57
D. CONSTRAINT LAYOUT ....................................................................... 57
E. Contoh Membuat Layout Menggunakan Linear Layout ...................... 57
F. Contoh Membuat Layout Menggunakan Relatif Layout ..................... 60
BAB 6 INTERAKSI ANTAR ACTIVITY (INTENT) ....................................... 63
A. INTENT .................................................................................................. 63
B. Cara Membuat Explicit Intent................................................................ 64
C. Cara Membuat Implicit Intent ................................................................ 67
D. Cara Mengirim Data Antar Activity ....................................................... 68
E. Studi kasus Radio Button ...................................................................... 73
F. Studi Kasus List View ............................................................................80
BAB 7 FRAGMENT....................................................................................... 83
A. URAIAN MATERI FRAGMEN .............................................................. 83
B. MEMBUAT FRAGMEN ......................................................................... 86
C. Mengelola Daur Hidup Fragmen ..........................................................88
D. Kode Fragmen ....................................................................................... 89
E. Cara membuat Kelas Fragmen di Android Studio .............................. 89
F. Implementasi Fragmen di Android Studio............................................ 90
BAB 8 AKSES GOOGLE MAPS, GPS ........................................................... 97
A. Persiapan Instalasi ................................................................................ 97
B. Membuat API Key .................................................................................. 98
C. Menambahkan Kunci API ke Aplikasi .................................................101
D. Menampilkan Maps pada Android Studio .......................................... 102
E. Memahami Kode.................................................................................. 104
BAB 9 Akses Internal Device Kamera........................................................ 107
xiv PEMROGRAMAN APLIKASI MOBILE

A. Pendahuluan ........................................................................................107
B. Persiapan ..............................................................................................107
C. Mengembangkan aplikasi kamera ......................................................107
BAB 10 Menggunakan Sensor Android - Accelerator ................................. 123
A. Pendahuluan ........................................................................................ 123
B. Tipe Sensor .......................................................................................... 123
C. Pengenalan Sensor.............................................................................. 123
D. Framework Sensor ...............................................................................126
E. Menggunakan Sensor ......................................................................... 128
BAB 11 Firebase ........................................................................................... 140
A. Pendahuluan ....................................................................................... 140
B. Firebase Realtime Database .............................................................. 140
C. Mengembangkan aplikasi CRUD menggunakan Firebase Realtime

Database ....................................................................................................... 141
D. Menambahkan Class Model Biodata .................................................. 147
E. Membuat Tampilan Untuk Melakukan Proses CRUD ...................... 148
F. Menambahkan Fitur Create (Menambahkan data ke firebase) ........ 153
G. Menambahkan Fitur Read (Menampilkan data dari firebase) ........... 156
H. Menambahkan Fitur Update dan Delete ............................................158
DAFTAR PUSTAKA .......................................................................................... 165
GLOSARIUM ....................................................................................................166
1 .........................................................................................................................166
Activity ...............................................................................................................166
: komponen yang menampilkan dan mengatur halaman aplikasi sebagai

tempat interaksi antara pengguna dengan aplikasi Android .........................166
2 .........................................................................................................................166
Accelerometer ...................................................................................................166
: sebuah perangkat yang mengukur percepatan yang tepat .........................166
PEMROGRAMAN APLIKASI MOBILE xv

3......................................................................................................................... 166
Class ................................................................................................................. 166
: Merupakan prototype yang mendefinisikan atribut dan methode secara

umum ................................................................................................................ 166
4......................................................................................................................... 166
Callback ............................................................................................................ 166
: Set inti yang disediakan class Activity untuk menavigasi transisi diantara
tahap siklus proses aktivitas ........................................................................... 166
5......................................................................................................................... 166
Console ............................................................................................................. 166
6......................................................................................................................... 166
Component tree ............................................................................................... 166
7......................................................................................................................... 166
Command line interface ................................................................................... 166
8......................................................................................................................... 166
Debug ............................................................................................................... 166
9......................................................................................................................... 166
Explicit intent .................................................................................................... 166
: berfungsi untuk mengaktifkan activity yang dibuat oleh user dalam satu
aplikasi yang sama .......................................................................................... 166
10 ...................................................................................................................... 166
Fragmen............................................................................................................ 166
: adalah bagian dari antarmuka pengguna dalam sebuah FragmentActivity

........................................................................................................................... 166
11 ...................................................................................................................... 166
Firebase ............................................................................................................ 166
12 ...................................................................................................................... 166
Intent ................................................................................................................. 166
: sebuah jembatan penghubung yang digunakan untuk perpindahan halaman

antar activity dalam aplikasi ............................................................................ 166
xvi PEMROGRAMAN APLIKASI MOBILE

13 ....................................................................................................................... 167
Implicit intent ..................................................................................................... 167
14 ....................................................................................................................... 167
Internal device ................................................................................................... 167
: Perangkat bawaan yang telah disediakan oleh smartphone android seperti

kamera, call, dialpad, dll ................................................................................... 167
15 ....................................................................................................................... 167
Method ............................................................................................................... 167
16 ....................................................................................................................... 167
Manifest ............................................................................................................. 167
17 ....................................................................................................................... 167
Object ................................................................................................................ 167
: Hasil instansiasi dari sebuah Class, memiliki atribut dan behaviour .......... 167
18 ....................................................................................................................... 167
Palette................................................................................................................ 167
19 ....................................................................................................................... 167
Statement .......................................................................................................... 167
20 ....................................................................................................................... 167
Toast .................................................................................................................. 167
INDEKS ............................................................................................................ 168
BIODATA PENULIS .........................................................................................170
PEMROGRAMAN APLIKASI MOBILE xvii

BAB 1
PENGENALAN JAVA DAN PEMROGRAMAN APLIKASI
MOBILE
Kenapa Android dan Java Dibutuhkan

Ketika Android pertama kali muncul di tahun 2008, popularitasnya
masih kalah dibandingkan dengan iOS di IPhone Apple. Secara
mengejutkan, melalui berbagai penawaran fitur, kepraktisan,
harga yang lebih bersahabat, serta teknologi yang digunakan oleh
android menyebabkan pengguna android meningkat dengan
pesat. Kebanyakan orang mengembangkan aplikasi android
karena android merupakan OS yang Open Source sehingga dapat
dikatakan sebagai salah satu bisnis yang paling bermanfaat.
Pengembangan aplikasi yang dimulai dari menyusun prototipe dari
pemikiran yang telah dibuat dengan cepat, serta kemampuan
android untuk mengolah, memperbaiki dan kemudian menjalankan
serta menghubungkan ke dalam aplikasi adalah proses yang
sangat menarik dan bermanfaat. Pemrograman itu sangat
bermanfaat mengingat perkembangan teknologi yang sudah
tersedia saat ini, dimana salah satunya adalah pemrograman
Android.
Karena sifat platform android yang gratis dan terbuka, pengguna
dapat mendistribusikan aplikasi yang telah dibuat tanpa
memerlukan izin dari siapapun, bahkan perusahaan-perusahaan
yang mengendalikan pasar dunia. Dunia android memiliki pasar
besar yang dikendalikan oleh perusahaan pengendali seperti
Amazon App Store dan Google Play Store dimana pengguna bisa
memasarkan produknya didalamnya. Pengguna dapat
mengembangkan aplikasi yang berinteraksi dengan dunia global
untuk mendidik, menghibur, menceritakan sebuah kisah dan
sebagainya dimanapun dan kapanpun, seperti di tempat kerja,
rumah, serta waktu luang ketika bekerja ataupun di hari libur.
Pengembangan aplikasi android membawa ribuan bahkan jutaan
peluang kerja di dunia.
Fakta menyebutkan bahwa pengembang android sangat dikagumi
dan dapat membuat memiliki pekerjaan yang dapat menghidupi
kebutuhan sehari-hari, atau bahkan bisa membuat kaya.
PEMROGRAMAN APLIKASI MOBILE 1

Pertumbuhan perangkat keras pada CPU dan GPU, serta evolusi
daru sistem operasi Android yang tanpa henti, kebutuhan
pengembang aplikasi professional akan terus tumbuh dari waktu
ke waktu.
A. Bagaimana Java dan Android Bekerja Sama

Calon pengembang aplikasi perlu memahami bagaimana Java
dan Android bekerja Bersama-sama. Ketika menulis sebuah
program dengan bahasa pemrograman java untuk android, kita
menekan sebuah tombol untuk menjalankan dan mentransformasi
koding yang telah kita buat kedalam bentuk lain yang dapat
dimengerti dan diterjemahkan oleh Android. Bentuk ini dinamakan
Dalvik Executable, atau disingkat sebagai kode DEX, dan
prosesnya dimakan compile.
Android merupakan sistem yang kompleks, namun pengguna
tidak membutuhkan pengetahuan yang dalam tentang sistem ini
untuk dapat menghasilkan aplikasi yang baik. Dalam memulainya,
kita hanya perlu memahami dasarnya yaitu bagian dari sistem
Android yang menjalankan atau executes code DEX yang sudah
di compile menggunakan Dalvik Virtual Machine (DVM). DVM
adalah sebuah perangkat lunak yang ditulis menggunakan Bahasa
pemrograman lain yang berjalan khusus dan diadaptasi
menggunakan sistem operasi Linux. Pengguna umum hanya
melihat Android adalah sebuah program umum yang berjalan,
padahal android menggunakan sistem operasi yang lain.
Kesimpulannya android adalah sebuah sistem didalam sistem,
pengguna umumnya tidak akan menyadari bahwa android
menggunakan sistem operasi Linux. Tujuan dari DVM adalah
untuk menyembunyikan kompleksitas dan keragaman baik dari
perangkat lunak maupun perangkat keras yang dijalankan oleh
Android, namun secara bersamaan menampilkan semua fitur-
fiturnya yang memiliki berbagai macam manfaat. Dalam
menampilkan fitur-fiturnya, DVM bekerja melalui dua cara: (1)
DVM harus memiliki akses ke hardware, dimana secara otomatis
telah dilakukan, serta (2) akses ini harus mudah digunakan serta
diolah oleh programmer maupun pengembang, jadi DVM
menggunakan Android Application Proggraming Interface atau
yang umumnya disebut dengan API.
2 PEMROGRAMAN APLIKASI MOBILE

B. API ANDROID
API Android adalah code yang membuat segalanya menjadi
mudah dalam menjalankan sebuah instruksi khusus. Analoginya
adalah pada pedal gas atau akselarator di mobil, Ketika kita
menekan akselarator, banyak hal yang terjadi di dalam proses
tersebut. Kita tidak perlu mengetahui tentang proses pembakaran
atau proses pembakaran yang dilakukan oleh bensin terhadap
mobil itu supaya dapat bergerak. Hal ini disebabkan karena
engineer telah membuat interface yang pintar untuk kita.
Sebagai contoh, potongan kode dari Bahasa Java di bawah ini
tampak sukar untuk dipahami di awal pertemuan, namun
potongan kode ini menyajikan agaimana API Android membantu
kita:
locationManager.getLastKnownLocation(LocationManager.GPS_P
ROVIDER)
Setelah memperhatikan dan mempelajari satu line kode diatas,
kode tersebut berfungsi untuk mencari satelit yang dapat
digunakan di luar angkasa, lalu pengguna berkomunikasi dengan
satelit tersebut di dalam orbitnya yang sedang mengelilingi bumi,
satelit tersebut kemudian memberikan posisi seseorang berada
sekarang secara live yang dihitung berdasarkan angka latitude
dan longitude di permukaan bumi. Dari contoh kasus diatas, salah
satu kekuatan dan kedalaman ilmu yang dimiliki API Android yang
terintegrasi di dalam DVM mulai dapat dimengerti dan dipahami.
Kode diatas tampak cukup menantang, dan terasa asing bagi
mereka yang belum pernah sama sekali mengenal pemrograman
Android menggunakan Java, namun bayangkan berbicara dengan
satelit dengan cara lain, pastinya lebih tidak terbayangkan.
API Android memiliki banyak kode Java yang telah ditulis dan siap
digunakan sesuai kebutuhan kita. Untuk memulainya kita
membutuhkan pemahaman tentang Bahasa pemrograman Java
dan Object Oriented Programming (OOP) yang dibahas dalam
buku ini.
C. Java adalah Object-Oriented
Java adalah bahasa pemrograman yang telah ada sebelum
Android, merupakan bahasa yang object oriented, yang memiliki
arti bahwa bahasa pemrograman ini menggunakan konsep

pemrograman objek yang apat digunakan kembali. Agar dapat
memahami lebih lanjut pendekatan bahwa Java memungkinkan
programmernya untuk menulis kode Java yang dapat disusun
berdasarkan hal – hal di dunia nyata, dan kode tersebut dapat
digunakan berulang kali kedepannya, dicontohkan dengan
menciptakan pemrograman oriented untuk melakukan perkalian,
dimana programmer tidak perlu menulis ulang semua kode dari
awal apabila programmer memasukkan angka yang berbeda,
programmer tersebut cukup memanggil fungsi perkalian,
memasukkan angka yang ingin dikalikan dan sistem akan
memprosesnya berdasarkan pendekatan dari OOP.
Contoh analogi kedua bagi yang masih belum memahami konsep
Object Oriented, adalah sebuah pemahaman berikut: jika sebuah
industri pabrik mobil membuat lebih dari satu unit dalam sehari,
apakah pekerjaan mendesain ulang setiap bagian untuk setiap
mobil perlu dilakukan setiap saat? Jawabannya tentu saja tidak.
Mereka menggunakan insinyur yang sangat terampil untuk
pengembangan teknologi dan komponen yang terus menerus
disempurnakan dan ditingkatkan performanya untuk versi dan tipe
selanjutnya. Sementara untuk versi dan tipe yang sama,
perusahaan industri tersebut akan menggunakan cetak biru yang
dibangun oleh insinyur, dan produksinya dilakukan oleh robot.
Dalam pemrograman Java cetak biru disebut kelas, ketika sebuah
kelas ditransformasikan menjadi “benda” yang bekerja nyata,
maka disebut sebagai objek atau turunan dari kelas.
Beberapa insinyur perangkat lunak di perusahan Android menulis
program Java yang sangat rumit dan kompleks untuk berbicara
dengan satelit. Kemudian insinyur tersebut mempertimbangkan
bagaimana dapat membuat agar kode ini berguna untuk semua
programmer Android yang ingin membuat aplikasi yang
menggunakan lokasi pengguna untuk melakukan hal- hal yang
keren dan menarik. Salah satu hal yang insinyur tersebut lakukan
adalah membuat fitur seperti mendapatkan lokasi perangkat di
dunia hanya dengan satu baris yang sederhana. Jadi sejatinya
satu baris kode yang telah dilihat sebelumnya menjalankan lebih
banyak baris kode yang tidak dilihat dan tidak perlu dilihat. Ini
adalah sebuah contoh menggunakan kode orang lain untuk
diadopsi dengan model bahasa pemrograman yang jauh lebih
simpel.

D. Apakah Android itu Sebenarnya?
Dalam menyelesaikan sebuah tugas menggunakan Android, kode
perlu ditulis menggunakan bahasa pemrograman java, serta dapat
juga menggunakan kode Java yang tersedia dalam API Android
yang umumnya dikenal sebagai library. Kemudian dikompllasi
kedalam kode DEX dan dijalankan oleh DVM, yang memiliki
koneksi ke sistem operasi dasar menggunakan Linux guna
menangani berbagai macam tipe perangkat keras yang kompleks
dan sangat beragam. Produsen perangkat Android serta produsen
perangkat keras (CPU, GPU, Penerima GPS, chip memori, dan
antarmuka perangkat) juga memastikan bahwa produk yang
dibuat selalu memenuhi kebutuhan dan dapat dapat berjalan pada
sistem operasi Linux yang mendasarinya.
Kode DEX (Bersama dengan sumber daya lainnya) ditempatkan
kedalam kumpulan file yang disebut Android Application
Package (APK) dan APK inilah yang dibutuhkan oleh DVM untuk
menjalankan aplikasi yang telah dibuat atau yang telah dimiliki.
Gambar 1.1 Lingkungan Android
E. Android Studio
Terdapat berbagai macam aplikasi yang dapat digunakan untuk
pengembangan Android, salah satunya adalah Android Studio,
kita membutuhkan dua hal sebelum memulai diantaranya adalah:
(1) Java Development KIT (JDK) Kita membutuhkan software
yang dinamakan Java Development Kit (JDK) yang
menerjemahkan koding yang telah dibuat ke bentuk kode DEX
yang dijalankan ke dalam DVM di dalam perangkat Android

pengguna. JDK juga menyertakan kode dari pengembang lainnya
yang terpisah dari API Android. (2) Software Development Kit
(SDK). Terdapat banyak perangkat yang dibutuhkan untuk
mendevelop sebuah aplikasi android dan API Android. Semua
perangkat yang dibutuhkan tersebut terdapat didalam Android
Software Development Kit (SDK). Android Studio memberi
kemudahan karena apa yang dibutuhkan sudah terbungkus
Bersama dalam satu aplikasi.
Android studio adalah sebuah Integrated Development
Environtment (IDE) yang akan menangani semua hal yang
berhubungan dengan mengkompile kode yang telah kita buat dan
menghubungkannya ke dalam JDK dan API Android.
F. Seputar Tentang Bahasa Pemrograman Java
Jika belum pernah belajar bahasa pemrograman Java namun
tidak asing dengan bahasa pemrograman C/C++/C# maka akan
lebih mudah dalam mengkoding menggunakan Java nantinya.
Java dirancang dengan menganut paradigma OOP, berbasis
kepada objek. Setiap membuat program maka diwajibkan untuk
membuat objek terlebih dahulu. Buku ini akan membahas hal ini
dengan prosedural spaya dapat dimengerti oleh pemula.
Sejarah singkat bahasa pemrograman Java berasal dari tahun
1991 oleh James Gosling, Patrick Naughton dan Mike Sherida.
Berawal dengan nama Oak, pohon yang berada di dekat kantor
James, kemudian diubah menjadi Green, dan pada akhirnya
menjadi Java, mereka terinspirasi oleh asal usul kopi yang sedang
diminum, yaitu pulau Jawa. Karena itu logo dari Java adalah kopi
panas yang diseduh di dalam cangkir.
Istilah istilah seputar Java yang perlu diketahui umumnya adalah
JDK, J2Se, Java SE, Java EE dan Java ME. JDK seperti yang
telah disebutkan diatas berisi library, tools dan API Android yang
dibutuhkan untuk membuat program. Didalam JDK terdapat pula
Java Virtual Machine (JVM), berguna sebagai mesin virtual yang
menjalankan runtime guna menjalankan kode dalam aplikasi java.
Java SE atau disebut dengan J2SE digunakan untuk membuat
aplikasi berbasis desktop dan command line (CLI). Java EE
adalah edisi enterprise yang digunakan untuk membuat aplikasi
perbankan, industri dan aplikasi yang berbau bisnis lainnya. JAVA
EE saat ini sudah berganti nama menjadi Jakarta EE. Java ME

adalah Java versi kecil yang digunakan untuk membuat aplikasi
mobile, sensor, mikro controller dan lainnya.
Java bersifat multi-Purpose yaitu berbasis (Dekstop, Android,
Web) dan bersifat multi-Platform yang dapat diakses oleh
perangkat yang memiliki OS (Windows, Linux, Mac) dengan file
berkestensi .jar. Bahasa pemrograman Java adalah salah satu
bahasa poluler di 2022 selain python.
Struktur dasar Program Java Secara Umum dibagi menjadi 4
bagian, yaitu: (1) Deklarasi Package, (2) Impor Library, (3) Bagian
Class, (4) Method Main.
Package adalah folder yang berisi sekumpulan program Java,
dilakukan saat membuat program atau aplikasi. Nama Package
mengikuti nama domain dari sebuah vendor yang membuat
ataupun pihak yang mengeluarkan program tersebut.
Impor library berisi sekumpulan class dan fungsi yang dapat
membantu programmer, dimana class dan fungsi tersebut telah
dirancang sebelumnya dan bisa digunakan dalam membuat
program oleh pihak lain.
Gambar 1.2 Struktur Dasar Program Java
Untuk memahami OOP, perlu pemahaman class sebagai

deklarasi nama program. Blok class dibuka dengan kurawal “{”
kemudian diakhiri dengan kurakhir “}”. Dalam blok ini dapat
diisikan dengan method, variabel dan juga fungsi-fungsi. Dalam
contoh Gambar 2 diatas, diisi dengan method “main”.

Method “Main()” adalah blok program yang akan dieksekusi
pertama kali, merupakan entry point dan wajib dibuat, jika tidak
maka program tidak dapat dieksekusi. Method “main()” memiliki
parameter “args[]” , dimana parameter ini nantinya akan
menyimpan sebuah nilai dari argumen yang terdapat di command
line. Kemudian di dalam method “main()” terdapat statement atau
fungsi untuk menampilkan teks ke layar monitor.
System.out.println("Hallo TT dan JTD"); adalah statement.
Statement dan ekspresi adalah bagian terkecil dalam program.
Dalam Java, harus diakhiri dengan titik koma “;”. Contoh
statement dan ekspresi dapat dilihat dalam Gambar 3. Statement
dan ekspresi akan menjadi instruksi yang dikerjakan oleh
computer.
Gambar 1.3 Contoh Statement dan Ekspresi
Contoh dibawah memerintahkan Java untuk menampilkan teks

”Hallo TT dan JTD”, “Apa Kabar ?”, dan menghitung nilai dari “JTD
+ TT” yang akan menghasilkan nilai 200 yang ditampilkan dalam
Gambar 4.
Gambar 1.4 Contoh Keluaran dari Statement
Prosedur, Fungsi maupun Method adalah sama. Prosedur

adalah sebutan untuk fungsi yang memiliki karakteristik tidak
mengembalikan nilai, biasanya ditandai dengan kata kunci ‘void’.
Fungsi adalah istilah untuk fungsi yang mengembalikan nilai.
Method adalah fungsi yang berada di dalam Class, dimana istilah
ini biasanya digunakan dalam OOP. Contok kodenya dapat dilihat

dalam Gambar 17. Keluaran kode ini ditampilkan dalam Gambar
18.
Gambar 1.5 Contoh Kode Fungsi
Gambar 1.6 Keluaran Kode Fungsi
Parameter adalah variable yang menampung nilai untuk diproses

didalam sebuah fungsi. Parameter memiliki fungsi sebagai nilai
masukan pengguna untuk fungsi. Contoh dari parameter
ditampilkan dalam Gambar 1.19, dan hasil keluarannya
ditampilkan dalam Gambar 1.20.
Gambar 1.7 Contoh Kode Parameter

Gambar 1.8 Keluaran Parameter
Setelah fungsi melakukan pemrosesan data yang diberikan

masukan data oleh user melalui parameter, selanjutnya fungsi
harus mengembalikan nilai agar dapat diolah lebih lanjut pada
proses selanjutnya. Pengembalian ini menggukan kata kunci
‘return’. Kode selanjutnya adalah kode berbasis OOP pada
Gambar 21, Gambar 22, dan Gambar 23. Kode ini adalah program
Create Read Update Delete (CRUD). Kode ini bersifat dinamis
dapat menerima masukan pengguna untuk memasukkan data jika
kita memasukkan nilai 2, dapat menunjukkan semua data yang
tersimpan apabila kita memasukkan nilai 1, dapat mengedit data
yang tersimpan apabila kita memasukkan nilai 3, dapat
menghapus data apabila kita memasukkan nilai 4, dan keluar dari
program apabila kita memasukkan nilai 5. Kode tersebut adalah
kode berbasis penyimpanan pada array. Apabila dijalankan
hasilnya tampak seperti Gambar 24.
OOP merupakan hal yang harus dipelajari untuk memahami Java
lebih dalam, karena Java Sendiri merupakan Bahasa yang
didesain untuk OOP. OOP digunakan Ketika program semakin
besar dan kompleks, proses memaintenance akan sulit untuk
dilakukan. OOP atau dalam Bahasa Indonesia lebih dikenal
sebagai Pemrograman Berorientasikan Objek, merupakan
paradigma atau Teknik pemrograman yang berorientasikan Objek.
Fungsi atau variabel pada OOP dibungkus dalam sebuah objek
atau class yang dapat saling berinetraksi, sehingga membentuk
sebuah program. Diharapkan dengan menerapkan OOP tidak ada
lagi kode yang “berantakan”, karena semua akan dibungkis di
dalam objek.
Program dalam Gambar 25 dan gambar 26 merupakan contoh
program lainnya berbasis OOP yang digunakan untuk
mendeklarasikan class hewan pada sebuah text editor. Terdapat 2
class dalam project ini, yaitu hewan.java dan harimau.java. Class

hewan dan harimau saling berkaitan, jadi class harimau dapat
memanggil method dari class hewan. Hasil kode ini ditampilkan
dalam Gambar 27.
Gambar 1.9 Kode OOP 1 Part 1

Gambar 1.12 Hasil Kode OOP 1
Gambar 1.13 Kode OOP 2 Class Hewan

Gambar 1.14 Kode OOP 2 Class Harimau
Gambar 1.15 Hasil Kode OOP

BAB 2
INSTALASI ANDROID STUDIO
A. Pendahuluan
Menginstall aplikasi Android studio memiliki beberapa persyaratan
minimum dan persyaratan rekomendasi spesifikasi perangkat
yang kita gunakan, diantaranya adalah:
1. RAM Minimal adalah 3 GB, direkomendasikan 4 Hingga 8 GB
(Catatan: Ram dibawah 4 GB sebaiknya tidak menggunakan
Virtual Device yang tersedia didalam Android Studio dalam
menampilkan hasil aplikasi yang telah kita buat, namun
melalui perangkat android yang kita miliki, Langkah-langkah
tersebut akan kita pelajari lebih lanjut di materi selanjutnya)
2. Penyimpanan yang tersedia direkomendasikan diatas 4 GB,
perhatikan sisa memori di Hard Disk atau SSD.
3. Resolusi layar minimum adalah 1280 * 800
B. Instalasi Android Studio

Adapun Langkah-langkah instalasi Android Studio Adalah sebagai
berikut
1. Download Aplikasi Android Studio melalui alamat website
https://developer.android.com/studio dan klik DOWNLOAD
ANDROID STUDIO seperti dalam Gambar 2.1
Gambar 2.1 Proses Instalasi Android Studio Part 1

2. Setelah mendownload file Android Studio, buka file tersebut
dan ikuti instruksi instalsasi berikut: (a) Klik Next untuk

melanjutkan proses instalasi (b) Berikan centang pada
Android Virtual Device (AVD) yang berfungsi untuk
mengkonfigurasi perangkat yang dijalankan dengan
emulator Android. (c) Klik Next untuk melanjutkan instalasi
seperti dalam Gambar 2.2

3. Memilih lokasi yang diinginkan untuk menginstall Android
Studio. Direkomendasikan menginstall di lokasi default,
yaitu C:\ProgramFiles\Android\Android Studio. Klik next
untuk melanjutkan proses instalasi. Pada proses ini
pastikan memori di Partisi C: tersedia sesuai rekomendasi
instalasi. Proses ini dapat dilihat dalam Gambar 2.3
4. Proses selanjutnya adalah menentukan nama pada aplikasi
android studio, rekomendasi dari kami adalah gunakan
nama Android Studio saja. Klik Install untuk melanjutkan
proses instalasi. Proses ini dapat dilihat dalam Gambar 2.4
5. Setelah menentukan nama aplikasi Android Studio dan klik
install, proses instalasi Android Studio akan dimulai,
silahkan menunggu hingga proses selesai kemudian kita
lanjutkan dengan menginstall Android Software
Development Kit (SDK). Proses ini ditampilkan dalam
Gambar 2.5
6. Menginstall SDK Android Studio, SDK pada Android Studio
Terbundle dalam aplikasi, hanya perlu mengkonfigurasi

saja. Langkah – Langkah yang harus dilakukan adalah: (a)
Setelah berhasil menginstall Android Studio, buka aplikasi
tersebut dan ikuti instruksi instalasi SDK dalam Gambar 2.6
Dalam gambar 2.6, klik next untuk melanjutkan ke proses
instalasi.

7. Memilih tipe instalasi: Untuk pilihan ini, mendapatkan

default pengaturan dan instalasi tambahan dari android
studio. (a) Custom: Untuk pilihan ini, pilih pengaturan dan
komponen tambahan yang diperlukan saja. Catatan: Tipe
instalasi standart memiliki ukuran file yang lebih besar
daripada custom, pastikan memori pada C: Tersedia. Pilih
salah satu instalasi yang diinginkan kemudian klik next.
Proses ini ditampilkan dalam Gambar 2.7

8. Memilih tampilan Android Studio, tersedia dua piihan

Dracula atau Light. Silahkan memilih tema yang membuat
mata nyaman. Klik Next Untuk Melanjutkan. Proses ini
ditampilkan dalam Gambar 2.8
9. Memilih komponen SDK Tambahan, Catatan: Langkah

pemilihan komponen SDK ini hanya akan muncul kalau
memilih tipe instalasi Custom. Jika memilih tipe instalasi
Standart, pilihan komponen SDK tidak akan didapatkan
karena semua komponen sudah dipilihkan secara default

dari Andrioid Studio. Sesuaikan komponen tambahan
yang dipilih seperti pada gambar di bawah ini, kemudian
klik Next untuk melanjutkan instalasi. Catatan: android
SDK Location disarankan sesuai dengan defautnya,
pastikan memori cukup. Proses ini Ditampilkan dalam
Gambar 2.9

10. Menentukan RAM untuk emulator. Sebaikanya gunakan
RAM minimal 4 GB agar tidak memperlambat proses
Running Emulator ketika menjalankan aplikasi yang telah
dibuat. Catatan: Jika computer / laptop hanya memiliki 4
GB RAM, sesuaikan dengan recommended yang
disarankan oleh Android Studio pada instalasi bagian
emulator settings. Proses ini ditampilkan Dalam Gambar
2.10. Klik Next untuk melanjutkan.
11. Mereview pengaturan instalasi, akan diberikan informasi
mengenai komponen tambahan SDK beserta ukuran
filenya. Klik Finish untuk memulai proses download
komponen-komponen tersebut. Proses ini ditampilkan
dalam Gambar 2.11

12. Proses Download dan Install SDK Android Studio, proses

ini hanya perlu menunggu hingga sampai selesai
mengunduh. Catatan: Proses download ini memiliki
ukuran yang besar. Oleh karena itu, pastikan koneksi
internet stabil agar tidak terjadi error saat proses instalasi
berlangsung. Apabila terjadi error ulangi terus proses
downloading components hingga berhasil. Apabila tetap
gagal menginstall berulang kali, silahkan mencoba
menginstallnya di Acess Point lain yang lebih cepat dan

stabil. Tampilan Proses ini ditampilkan dalam Gambar
2.12
13. Setelah proses download dan install selesai, akan muncul

tampilan seperti gambar 2.13 di bawah ini:
Gambar 2.13 Proses Instalasi Android Studio Selesai

C. Membuat Project Sederhana di Android Studio
Sebagai Latihan, berikut cara untuk membuat project sederhana
menggunakan aplikasi Android Studio
1. Buka aplikasi Android Studio, klik Create New Project

2. Pada bagian Select a Project Template, pilih tab Phone
and Tablet, pilih Empty Activity, klik Next, seperti pada
Gambar 2.14 berikut ini.
Gambar 2.14 Proses Membuat Project Sederhana Part 1

3. Pada bagian Configure Your Project: (A). masukkan nama
project, maka package name akan ikut menyesuaikan
(Catatan: jangan mengubah nama di Package name). (B)
Jika ingin menempatkan project di folder lainnya, ubah
lokasi Save Locationnya. (C) Pilih language Java. (D) Pilih
versi terendah Android yang akan didukung aplikasi di
kolom minimum SDK. (E) Klik Finish.
4. Setelah beberapa waktu pemrosesan, jendela utama
android studio akan muncul. Ditampilkan dalam Gambar
2.15
5. Silahkan meninjau file-file yang penting pada percobaan
ini:
(A). Pertama, pastikan jendela Project terbuka (pilih View >
Tool Windows > Project) dan tampilan Android dipilih dari
menu drop-down di bagian atas jendela tersebut.
Kemudian, lihat file berikut: app > java >
com.example.ujicobaandroidstudio > MainActivity. Ini
adalah aktivitas utama. Ini adalah titik masuk ke aplikasi.
Saat membuat dan menjalankan aplikasi, sistem akan
meluncurkan instance Activity ini dan memuat tata
letaknya.

(B) app > res > layout > activity_main.xml. File XML ini
menentukan tata letak antarmuka pengguna (UI) aktivitas.
File ini berisi elemen TextView dengan teks "Hello, World!",
kita dapat mengubah tampilan desain dari tampilan koding
pada menu di kanan atas. Ditampilkan dalam Gambar
2.16.
Gambar 2.15 Layar Utama Android Studio
Gambar 2.16 Activity Main.xml

(C) app > manifests > AndroidManifest.xml.
File manifes menjelaskan karakteristik dasar aplikasi dan
menentukan masing-masing komponennya. Ditampilkan
dalam Gambar 2.17

Gambar 2.17 Android Manifest.xml
6. Menjalankan aplikasi dapat dilakukan di perangkat

sungguhan maupun di emulator, pada kesempatan kali ini
akan membahas menjalankan aplikasi di emulator.
(A) Pilih virtual device yang diinginkan. Seperti dalam
Gambar 2.18 dan klik Run APP seperti dalam Gambar
2.19
Gambar 2.18 Memilih Virtual Device

Gambar 2.19 Menjalankan Program Melalui Virtual Device
(B) Apabila telah tampil halaman bertulisan “Hello World”

maka Android Studio sudah berhasil terinstall. Catatan:
lama waktu Gradle build ditentukan pada RAM yang di
alokasikan sebelumnya. Catatan: Apabila dirasa waktu
build terlalu lama, gunakan perangkat android pada
pembahasan di bawah ini.
7. Menjalankan Program di Perangkat Android memiliki
beberapa persiapan, diantaranya adalah: menghubungkan
perangkat ke mesin pengembangan dengan kabel USB.
8. Melakukan langkah-langkah berikut untuk mengaktifkan
proses debug USB pada jendela Opsi Developer:
(A) Buka aplikasi Setelan (settings)
(B) Pilih Tentang Ponsel (about phone)
(C) Ketuk Nomer Build (Build Number/ MUI version) tujuh
kali sehingga muncul youre a developer
(D) Kembali ke layer sebelumnya, scroll ke bagian bawah,
dan ketuk Opsi Developer (developer options) Catatan :
setiap brand HP memiliki lokasi developer options yang
berbeda tempatnya. Dalam kasus saya developer
options terletak didalam pengaturan tambahan
(Additional settings)
(E) Di jendela Opsi Developer, scroll kebawah untuk
menemukan dan mengaktifkan proses debug USB
(USB debugging) dan aktifkan pula menu Install Via
USB

(F) Ketuk Accept dan OK ketika menyambungkan kabel
USB android dan computer/laptop. Proses ini
ditampilkan dalam Gambar 2.20
Gambar 2.20 Mengaktifkan Mode Developer dan USB

Debugging
9. Jalankan aplikasi di perangkat sebagai berikut:
(A) Di Android Studio, pilih aplikasi dari menu drop-down
konfigurasi Run/Debug di toolbar
(B) Di Toolbar, pilih perangkat Android sungguhan, seperti
dalam Gambar 2.21
(C) Klik Run, Android Studio akan menginstall aplikasi di
perangkat yang terhubung dan menjalankannya.
Setelah itu lihat “Hello World” di tampilkan dalam
aplikasi perangkat. Ditampilkan dalam Gambar 2.22

Gambar 2.21 Pemilihan Android Pengguna untuk Menjalankan
Aplikasi
Gambar 2.22 Tampilan Program di Aplikasi Pengguna

BAB 3
STRUKTUR PROJECT ANDROID
A. Struktur Project
Setiap project di Android Studio terdiri dari beberapa modul
dengan file kode sumber dan file resource. Jenis modul meliputi:
• Modul aplikasi Android
• Modul library
• Modul Google App Engine
Secara default, Android Studio menampilkan file project dalam
tampilan project Android, Tampilan ini disusun menurut modul
untuk memberikan akses cepat ke file sumber utama project
(Android.developer)
Secara umum struktur project android terdiri dari tiga folder utama,
yaitu :
1. Manifest: Digunakan untuk menjelaskan informasi penting
tentang aplikasi dan dapat melakukan beberapa pengaturan
yang dibutuhkan dalam project, seperti Nama aplikasi, icon
aplikasi, theme style, User permission (jika membuat
aplikasi yang membutuhkan akses hardware smartphone
maupun internet). Setiap aktivitas yang dibuat harus
terdaftar pada file manifest.
2. Java: Berisi file kode sumber Java, yaitu tempat untuk
mendeklarasikan atribut, pengenalan komponen dan fungsi
– fungsi termasuk kode pengujian JUnit.
3. Res: Berisi semua resource non-kode seperti drawable dan
mipmap untuk menyimpan icon atau gambar, file layout
XML untuk mendesain tampilan, dan berisi kode-kode yang
sederhana seperti string, integer dan warna.
B. Cara Membuat Project

Sebelum memulai program pertama dalam android studio,
pengguna harus memahami struktur project android, cara
membuat project, fungsi masing-masing folder, cara menjalankan
program dan cara membuat activity. Setelah berhasil menginstal
android studio dan emulator, ketika pertama kali membuka
android studio maka akan muncul tampilan seperti dibawah ini.

Gambar 3.1 Layar Pembuka Android Studio
Untuk membuat aplikasi pertama, maka pilih Start a new Android
Studio Project, kemudian buat project dengan nama
ProjectPertamaku, setelah berhasil membuat project, maka akan
muncul tampilan seperti dibawah ini
Gambar 3.2 Jendela Configure Your Project

1. Name : Merupakan nama untuk project yang akan di bangun

2. Package Name: Merupakan alamat Website, sekolah,
perusahaan atau yang lainnya, kolom ini harus diisi, jika tidak
ada bisa diisi dengan contoh com.example.MyFirstApp
3. Save Location: Merupakan lokasi dimana Project yang
dibangun akan di simpan.
4. Minimum API Level : Pada bagian ini pilihlah versi terendah
android yang didukung oleh aplikasi. Biasanya sistem akan
menyarankan untuk memilih minimum SDK. Secara default
minimum SDK menggunakan API 15: Android 4.0.3 (Ice
Cream Sandwich).
5. Setelah di klik finish, maka selanjutnya tunggu hingga
proses selesai dan akan muncul tampilan seperti di bawah
ini.
6. Jika akan membuat pengaturan layout yang digunakan
untuk interface utama maka klik pada folder layout →
activity_main.xml
C. Jendela Utama Android Studio
Gambar 3.3 Jendela Utama Android Studio
Berikut penjelasan bagian-bagian dari android studio secara garis

besar

1. Folder Bagian Android Studio : Merupakan bagian dari
susunan folder project Android Studio, terdapat beberapa
folder penting yaitu folder manifest, folder java, folder res, dan
gradle.
2. Pallete : Berisi beberapa tools atau komponen yang bisa
digunakan untuk membuat Graphic User Interface
3. Component Tree Layout : Merupakan component Tree yang
memiliki fungsi menampilkan Layout dan susunan dari
komponen yang digunakan
4. Layar Utama : Merupakan Layar utama untuk mendesain
interface sesuai kebutuhan
5. Properties : Bagian ini digunakan untuk menampilkan semua
informasi dan mengatur komponen yang dipilih seperti
nama_id, ukuran/Size, Font, Background, Color dll
Terdapat struktur folder utama pada Android Studio, berikut

penjelasan folder tersebut :

Gambar 3.4 Struktur Folder Android
1. Manifest (AndroidManifest.xml)
File manifest merupakan element root sumber project yang
digunakan untuk menjelaskan informasi penting tentang aplikasi
dan dapat melakukan beberapa pengaturan yang dibutuhkan
dalam project, seperti Nama aplikasi, icon aplikasi, theme style,
User permission (jika membuat aplikasi yang membutuhkan akses
hardware smartphone maupun internet).
Jika pengguna membuat Activity baru maka Activity tersebut pasti
tercatat pada file manifest, jika tidak maka periksa kembali dan
bisa ditambahkan secara manual. dan jika pengguna ingin

membuat aplikasi yang membutuhkan koneksi Internet, pengguna
harus mengisi User Permission di File ini, mengganti judul, icon,
dan lain sebagainya. Berikut ini contoh file AndroidManifest.xml
Gambar 3.5 Contoh File Manifest
Berikut ini adalah penjelasan bagian-bagian file Manifest:

1. <manifest>
Manifest berisi nama package di Activity class yang
merupakan element root di file AndroidManifest.xml, Biasanya
menyesuaikan struktur directory project, Dengan demikian,
nama dalam atribut package manifest selalu cocok dengan
nama paket dasar project, yaitu tempat untuk menyimpan
kode aplikasi dan aktivitas lainnya.
2. <application>
Application merupakan icon dan label default untuk setiap
komponen aplikasi yang merupakan sub element dari
manifest. Application digunakan untuk mendeklarasian icon,
nama judul aplikasi, pendeklarasian tema, dll
• android:allowBackup= untuk mengizinkan aplikasi untuk
merestore infrastructure

• android:icon : digunakan untuk mendeklarasikan icon
launcher semua komponen Aplikasi.
• android:label : digunakan untuk mendeklarasikan nama
judul semua komponen Aplikasi.
• android:theme : digunakan untuk mendeklarasikan
tema semua komponen Aplikasi.
3. <activity>
Activity disini digunakan untuk mendeklarasikan semua
aktivitas yang terdapat pada aplikasi, setiap pengguna
membuat suatu Activity baru, maka nama activity tersebut akan
tercatat pada file manifest. Activity merupakan sub element dari
<application>
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
android:name : mendeklarasikan nama dari class Activity.

Apabila suatu activity memiliki <category
android:name="android.intent.category.LAUNCHER /> itu berarti
bahwa activity tersebut merupakan activity yang pertama kali
dijalankan.
2. Java (MainActivity.java)
Dalam folder java, terdapat 3 folder dengan nama yang sama
sesuai dengan package name pada file manifest, dimana pada
manifest package name nya adalah
polinema.ac.id.projectpertamaku. Ketiga folder tersebut meski
memiliki nama yang sama akan tetapi memiliki fungsi yang
berbeda.

Gambar 3.6 Folder Java
Pada folder pertama terdapat nama package berisi file class

Activity java, yang bisa kita ambil contoh bernama
MainActivity.java. File ini adalah sebuah class yang digunakan
untuk mendeklarasikan atribut, pengenalan komponen yang
digunakan pada file layout dan membuat fungsi-fungsi yang
dibutuhkan dalam program.
Sedangkan pada folder kedua dan ketiga berisi file yang
digunakan untuk testing.
3. Java (Generated)
Pada folder ini berisi kode program yang di generate oleh android
studio, pengguna dilarang merubah kode program pada folder
java (Generated) dalam kondisi apapun.
4. Folder Res → Drawable

Folder ini digunakan untuk memasukkan gambar pendukung atau
icon yang nantinya akan digunakan untuk membuat desain layout.

Biasanya digunakan untuk menampilkan gambar statis di aplikasi.
Isi pada folder drawable dapat berupa sebuah gambar atau xml
drawable dengan syarat penamaan pada folder ini tidak boleh
menggunakan angka, huruf kapital dan menggunakan underscore
sebagai pendukung antar kata (jika ada spasi)
Ada dua cara yang digunakan untuk menentukan dan membuat
instance drawable selain menggunakan class constructor
• Meluaskan resource gambar (file bitmap) yang
tesimpan didalam project
• Meluaskan Resource XML yang menentukan properti
drawable
5. Folder Res → Layout
Folder ini menyimpan file-file dalam bentul .xml yang digunakan
untuk pengaturan layout sebagai user interface utama pada
aplikasi android yang dibuat
Layout.xml digunakan untuk membuat tampilan activity atau
fragment pada android studio. File layout ini berbentuk tag xml
dimana masing-masing tag memiliki aturan - aturan sendiri seperti
pada kode html untuk aplikasi web.
6. Folder Res → Mipmap
Folder ini digunakan untuk memasukkan gambar berupa icon.
Icon default aplikasi yang dibuat juga diambil dari folder ini. Folder
mipmap ini hampir sama dengan folder drawable, perbedaannya
adalah pada folder mipmap pengguna dapat membuat folder lagi
dan bisa meletakkan icon bar untuk project android.
7. Folder Res→ Values
Folder ini berisi file XML yang berisi kode-kode yang sederhana
seperti string, integer dan warna. Berikut adalah beberapa file xml
yang terdapat dalam folder value:
• Colors.xml : file ini digunakan untuk menulis kode-
kode pengaturan warna. Warna status bar, teks juga
bisa disebut theme dasar dari aplikasi android
• Dimensi.xlm : file ini digunakan untuk pengaturan
margin aplikasi

• Strings.xml : file ini digunakan untuk pengaturan teks
teks aplikasi yang dibuat
• Styles.xml : file ini digunakan untuk memberikan nama
warna setelah kode-kode warna dimasukkan atau
disetting pada
8. Gradle
Gradle merupakan build system yang digunakan oleh android
studio, file ini berisi konfigurasi konfigurasi penting mengenai
proses build aplikasi. File gradle pada sebuah project android
studio terdiri dari dua level yaitu level project dan level module,
sebuah project android minimal memiliki 2 file gradle, jika project
tersebut memiliki modul lebih dari satu maka file gradle nya akan
bertambah sesuai dengan jumlah module yang dimiliki.
Gambar 3.7 Gradle

Berikut ini isi dari file gradle pada module app

Gambar 3.8 File Gradle Pada Module App
Pada file gradle ini berisi semua library dan konfigurasi yang
digunakan untuk module app termasuk koneksi dengan firebase
Sedangkan gradle pada level project berisi repository mana yang
digunakan untuk memeriksa dependency aplikasi yang di isi pada
file gradle module.

BAB 4
ACTIVITY
A. Activity
Activity adalah komponen yang menampilkan dan mengatur
halaman aplikasi sebagai tempat interaksi antara pengguna
dengan aplikasi Android. Ketika membuat project maka Class
MainActivity akan tergenerate secara otomatis, Class tersebut
merupakan extends dari Class Activity.
Sebagian besar aplikasi terdiri dari beberapa layar, satu layar
tersebut itulah yang disebut activity, jadi satu aplikasi bisa memiliki
banyak activity. Activity terdiri dari file Java class dan file xml
untuk mendesain layout.
Biasanya, dalam sebuah aplikasi akan ditetapkan satu aktivitas
sebagai aktivitas utama, yang merupakan layar pertama yang
dibuka saat pengguna menjalankan aplikasi. Setiap aktivitas dapat
memanggil aktivitas lain untuk melakukan tindakan yang berbeda
yang biasa disebut dengan intent. Semua aktifitas dalam aplikasi
harus terdaftar pada file manifest, aktivitas utama yang dijalankan
pertama kali ditandai dengan kategori Launcher pada file
manifest.
B. Activity Life Cycle (Daur Hidup Activity)

Untuk transisi di antara siklus proses aktivitas, class activity
menyediakan 6 callback yaitu onCreate(), onStart(),
onResume(), onPause(), onStop() dan onDestroy(). Callback ini
dipanggil sistem ketika aktivitas memasuki status baru.

Gambar 4.1 Daur Hidup Activity
Sumber : developer.android.com
Dilansir dari developer.android.com terdapat serangkaian callback
yang digunakan untuk menangani transisi antar status, yaitu:
1. onCreate() : Methode ini dipanggil ketika membuat suatu
aktifitas, pada methode ini biasanya dilakukan pengenalan
komponen yang digunakan pada layout dan merupakan
tempat untuk memanggil method setContentView () untuk
menentukan tata letak pengguna activity.
Fungsi setContentView() digunakan untuk menghubungkan
Activity dengan tampilan antarmuka layout yang telah
dibentuk pada xml, Sedangkan untuk pengenalan komponen
widget pada activity digunakan fungsi findViewById(). Untuk

membuat activity dapat dilakukan secara manual atau
menggunakan template yang disediakan oleh android studio.
2. onStart () : Callback ini dipanggil saat aktivitas memasuki
status dimulai, dan aktivitas menjadi terlihat oleh pengguna.
Callback ini merupakan persiapan akhir aktivitas untuk dikirim
ke user interface dan menjadi interaktif.
3. onResume() : callback ini dipanggil sebelum aktivitas mulai
berinteraksi dengan pengguna. Aktivitas ini berada pada
tumpukan teratas aktivitas-aktivitas yang lain, sebagian besar
aplikasi berinteraksi dengan pengguna pada
metode onResume().
4. onPause() : Merupakan indikasi ketika user meninggalkan
suatu aktivitas. Aktivitas yang ditinggalkan oleh user bisa
berganti status menjadi berhenti atau dilanjutkan.
5. onStop () : Sistem memanggil callback ini saat aktivitas tidak
lagi terlihat oleh pengguna. Biasanya terjadi karena sebuah
aktivitas baru dipanggil, atau karena suatu aktivitas baru saja
diakhiri. Aktivitas yang dihentikan tidak lagi terlihat sama
sekali.
6. onRestart () : Sistem memanggil callback ini jika akan
memulai aktivitas yang statusya berhenti
7. onDestroy () : Sistem akan memanggil callback ini ketika
akan mengakhiri suatu aktivitas. onDestroy() biasanya
diterapkan untuk memastikan bahwa semua resource aktivitas
akan dilepas jika aktivitas atau proses yang berisi callback
tersebut diakhiri.
Berikut ini langkah langkah untuk membuat sebuah activity.
1. Klik kanan pada package yang ada pada new project
kemudian pada menu yang ada pilih menu activity kemudian
pada pilihan template pilihlah empty activity

Gambar 4.2 Cara Membuat Activity
2. Kemudian pada dialog yang muncul isikan nama activity
yang akan dibuat, pada screenshot ini dibuat sebuah activity
dengan nama Next Activity
Gambar 4.3 Configurasi Activity

3. Klik finish, ketika tombol finish di klik maka Android Studio
akan melakukan pembuatan sebuah activity yang terdiri dari
satu file java NextActivity dan file xml activity_next.xml dan
mendaftarkannya ke android manifest
Gambar 4.4 Tampilan Awal Activity
4. Setiap activity yang dibuat akan didaftarkan otomatis ke

dalam android manifest, android manifest yang sudah
terupdate dapat dilihat pada gambar dibawah ini
Gambar 4.5 Android Manifest

5. Membuat sebuah activity juga dapat dilakukan secara
manual yaitu dengan cara membuat sebuah class yang

mengextend ke class AppCompatActivity kemuadian
membuat sebuah file layout xml dan memanggilnya pada
fungsi onCreate() yang dibuat dan selanjutnya adalah
mendaftarkan activity tersebut ke Android Manifest.
C. Latihan
1. Buat project dengan nama AndroidLifeCycle
2. Pada project Android secara otomatis akan dibuatkan
Activity utama dengan nama MainActivity yang
didefinisikan dalam MainActivity.java serta
activity_main.xml untuk pengaturan layoutnya. Selain itu,
pada Activity dibuatkan juga default callback onCreate().
3. Untuk memahami lebih lanjut mengenai lifecycle pada
Android, tambahkan dua callback onStart() dan juga
onStop() dengan override. Sehingga hasil akhir menjadi
seperti pada gambar berikut.
Tips: Untuk melakukan override gunakan shortcut Ctrl + o

kemudian pilih nama method yang akan di-override. Atau

dapat langsung mengetikkan nama method yang akan di-
override kemudian dilanjutkan dengan Ctrl + space dan
Enter. Contoh: onSt Ctrl + space akan muncul suggestion
onStart()
Catatan: Toast digunakan untuk menampilkan pesan pop up
pada Android. Toast.LENGTH_SHORT mengatur berapa
lama pesan pop up akan ditampilkan. Secara umum struktur
code Toast sebagai berikut.
Toast.makeText(this, "This is a message",
Toast.LENGTH_SHORT).show();
4. Jalankan kode tersebut.

5. Perhatikan tampilan pop up yang keluar ketika aplikasi
dijalankan.
6. Lengkapi kode seperti gambar berikut kemudian
jalankan kembali.

D. Cara Membuat Activity Sederhana
Pada Latihan sebelumnya telah dipelajari bagaimana daur hidup
aplikasi Android. Pada Activity terdapat dua buah file, yaitu .java
dan .xml. Untuk menghubungkannya, pengguna dapat mengikuti
langkah-langkah berikut untuk mempelajarinya.
1. Pada project ProjectPertamaku tambahkan Activity (Empty

Activity), beri nama SimpleActivity. Caranya dengan klik
kanan folder yang terdapat pada folder java → new →
activity → Empty Activity seperti gambar berikut ini
Gambar 4.6 Membuat Aktivitas Baru
2. Selanjutnya buat Activity dengan nama SimpleActivity,

dan jangan lupa klik Launcher Activity, hal ini digunakan
untuk menandakan bahwa activity pada tag ini merupakan
activity yang pertama kali dibuka.

Gambar 4.7 Configure Activity
3. Setelah selesai maka akan muncul 2 macam file yaitu
SimpleActivity.java yang terdapat pada folder Java, dan
activity_simple.xml yang terdapat pada folder res yang
akan digunakan untuk mendesain tampilan, lalu buka
activity_simple.xml maka akan terdapat 2 macam
tampilan yaitu design dan text. Design digunakan untuk
drag and drop komponen serta melengkapi atributnya
sedangkan Text tampilan dalam bentuk xml nya. Berikut
adalah tampilan pada activity_simple.xml .

Gambar 4.8 Tampilan Desain activity_simple.xml
4. Pada ComponenTree jika default layer adalah constrain
layout maka ubah menjadi linear layout dengan cara klik
kanan pada ConstrainLayout → convertView → pilih
LinearLayout kemudian ubah orientasi LinearLayout dari
horizontal menjadi vertical dengan cara klik kanan
LinearLayout → convert orientation to vertikal
5. Selanjutnya Drag and Drop 3 komponen 1) PlaintText 2)
Button dan 3) Text View ke dalam layar utama android,
dan pastikan Tampilan Componen Tree seperti pada
gambar berikut

Gambar 4.9 Tampilan EditText dan Button
6. Selanjutnya mengubah Id dan text pada properties hal ini

berfungsi untuk mempermudah penamaan, bisa dilakukan
dengan cara klik komponen yang akan diubah kemudian
edit di properties
Id Edit_text diubah menjadi input_name dan text name

diganti “masukkan nama”
Id Button diubah menjadi button_submit dan text name
diganti “SUBMIT”
Id TextView diubah menjadi output_name dan text name
dihilangkan
Berikut ini adalah contoh pengubahan pada komponen
Plain Text

Gambar 4.10 Mengubah Nama Id
Gambar 4.11 Mengubah Text

7. Langkah selanjutnya adalah coding pada file
SimpleActivity yang terletak di folder java, ada 3 hal yang
perlu ditambahkan pada file .java yaitu :
a. Pendeklarasian Atribut
b. Pengenalan Komponen, disesuaikan dengan
penamaan id pada komponen
c. Even Handling, action yang akan terjadi jika button di
klik
public class SimpleActivity extends AppCompatActivity {
//1. Pendeklarasian Atribut

private EditText inputName;
private TextView outputText;
private Button button;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_simple);
//2. Pengenalan Komponen
inputName = findViewById(R.id.input_name);
outputText = findViewById(R.id.output_name);
button = findViewById(R.id.button_submit);
}
}
Untuk even handling, perlu ditambahkan Layout pada
Android menggunakan struktur xml. Setiap komponen
mempunyai atribut-atribut dengan format key dan value.
Atribut android:id digunakan untuk memberikan identitas
pada suatu komponen Android.
8. Buka file activity_simple.xml pada bagian text, lalu pada
tag button tambahkan android:onClick="handleSubmit"
kemudian pindahkan cursor pada baris yang memuat kode
“handleSubmit” kemudian tekan tombol shortcut Alt +
Enter dan pilih Create 'handleSubmit(View view)' in
'SimpleActivity'. Android Studio akan menambahkan
secara otomatis method pada file SimpleActivity. Proses
ini digunakan untuk menambahkan logika pada Activity
ketika tombol ditekan.

Gambar 4.12 Tampilan Text XML
Selanjutnya pilih SimpleActivity kemudian klik OK
Gambar 4.13 Tampilan Membuat Even Handling

9. Tambahkan kode berikut pada method
handleSubmit(View view) untuk menampilkan nilai nama
dari EditText yang ditampilkan ke TextView ketika Button
ditekan.
//even handling
public void handleSubmit(View view) {
String name = inputName.getText().toString();
outputText.setText("Hello " + name);
}
10. Kemudian Jalankan program, maka akan muncul tampilan

seperti dibawah ini
Gambar 4.14 Tampilan Program Execute

11. Terdapat cara lain yang bisa digunakan untuk even
handling, yaitu dengan mengetikkan
button.setOnClickListener lalu klik new didalam tanda

kurung kemudian akan muncul pilihan dan pilih onClick
(view view) maka otomatis akan dibuatkan methode
seperti dibawah ini
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
String name = inputName.getText().toString();
outputText.setText("Hello " + name);
}
});
SOAL
1. Bagaimana membuat tulisan “Masukkan nama” pada project
diatas menjadi transparant ?
2. Buatlah Activity sederhana yang dapat digunakan untuk
memasukkan dan menampilkan data-data mahasiswa seperti
dibawah ini :
Nim :
Nama :
Kelas :
IPK :

BAB 5
LAYOUT
A. LAYOUT
Secara bahasa, layout adalah tata letak. Menurut Surianto
Rustan, layout adalah tata letak dari komponen-komponen
desain terhadap suatu bidang dalam media tertentu untuk
mendukung konsep atau pesan yang dibuat. (Rustan, Suriyanto
2001)
Secara sederhana, definisi layout adalah desain tata letak,
sedangkan arti dari layout adalah suatu susunan, rancangan,
atau tata letak ruang dari sebuah elemen yang sengaja didesain
untuk bisa ditempatkan dalam suatu bidang yang telah di desain
sebelumnya. (Rheny, Silvia, 2022)
Desain layout mencakup pengaturan teks, gambar, dan elemen
visual dalam kotak untuk menyampaikan pesan tertentu. Fungsi
dan tujuan layout adalah untuk mempermudah komunikasi
antara pengguna dengan aplikasi, atau membuat interface yang
bersifat user friendly.
Terdapat 3 jenis layout utama pada android studio yaitu Linear
Layout, Realtife Layout dan Constraint Layout. Akan tetapi
default layout pada android studio adalah constraint layout.
B. LINEAR LAYOUT
LinearLayout adalah kelompok tampilan yang menampilkan
semua komponen dalam satu arah, yaitu vertikal maupun
horizontal. Semua komponen LinearLayout akan disejajarkan
satu sama lain, sehingga orientasi vertikal hanya akan memiliki
satu turunan per baris, dan orientasi horizontal hanya akan
setinggi satu baris.
Linear layout adalah salah satu layout termudah untuk
mendesain sebuah aplikasi, karena pengguna hanya tinggal
drag and drop komponen, dan secara otomatis komponen akan
tersusun secara vertikal maupun secara horizontal.

C. RELATIF LAYOUT
RelativeLayout adalah tata letak tampilan yang dapat
menampilkan tampilan turunan di posisi sesuai kehendak user.
Posisi setiap komponen yang dipilih dapat ditentukan sebagai
posisi relatif terhadap elemen lain yang setara, sebagai contoh
komponen diletakkan di sebelah kiri atau di bawah tampilan lain
atau di posisi relatif terhadap RelativeLayout induk (seperti
sejajar dengan komponen sebelumnya bagian bawah, kiri, atau
tengah). (android developers 2022)
D. CONSTRAINT LAYOUT
ConstraintLayout memungkinkan pengguna untuk membuat tata
letak yang kompleks dan besar dengan hierarki tampilan datar
(tidak ada kelompok tampilan bertingkat). ConstraintLayout
serupa dengan RelativeLayout yang mana semua tampilannya
diletakkan sesuai kehendak user, asal tetap memperhatikan tata
letak induk, ConstrainLayout lebih fleksibel
daripada RelativeLayout dan lebih mudah digunakan dengan
Layout Editor Android Studio. (android developers 2022)
Dengan menggunakan constraint Layout, pengguna dapat
mendesain komponen secara flexible, constrain layout juga
menawarkan kecanggihan yang tidak dimiliki linear layout
maupun relatif layout.
Fitur Visual Layout Editor menawarkan semua kecanggihan
ConstrainLayout, karena API layout dan Layout Editor dibuat
khusus untuk digunakan bersama-sama.
E. Contoh Membuat Layout Menggunakan Linear Layout

1. Buatlah sebuah project baru yang bernama LinearLayout.
Kemudian bukalah file activity_main.xml yang terletak pada
folder Res. Sehingga muncul tampilan seperti dibawah ini

Gambar 5.1 ActivityMain.xml
2. Bisa dilihat bahwa default layout adalah constraint layout,
maka lakukanlah konversi dari constraint layout ke linear
layout dengan cara klik kanan constrain layout → convert
view → linear layout
Gambar 5.2 Convert View Ke Linear Layout

3. Selanjutnya ubah orientation linear layout dari vertikal layout
menjadi horizontal layout

Gambar 5.3 Ubah Orientasi Linear Layout
4. Selanjutnya drag and drop Textview, dan 3 button ke dalam

layout, ubah warna button menjadi warna biru, sehingga jika
menggunakan vertical linear layout hasil keluaran seperti yang
ditunjukkan dibawah ini

Gambar 5.4 Tampilan Desain Layout
5. Pada bagian atribut, ubah layout_width dan layout_height dari
match_parent menjadi wrap content, lalu buatlah kesimpulan
apakah perbedaan match_parent dengan wrap_content ?
Gambar 5.5 Atribut Layout

F. Contoh Membuat Layout Menggunakan Relatif Layout
4. Untuk membuat contoh relatif layout, ubah layout menjadi
relatif layout, drag and drop 2 button
5. Ganti text botton satu menjadi “TOP” dan button 2 menjadi
“Bottom”
6. Ubah ke mode split di pojok kanan atas, sesuaikan dengan
kodingan dibawah ini

Gambar 5.6 Contoh Relatif Layout 1
7. Pada button pertama dapat dilihat bahwa button
mempunyaiproperties
android:layout_alignParentStart = "true"
android:layout_alignParentLeft = "true"
android:layout_alignParentTop = "true"
8. Dengan konfigurasi properties seperti diatas, sebuah item

akan diposisikan disebelah kiri atas, sedangkan pada
button 2 mempunyai properties
android:layout_alignParentBottom = "true"
9. Dengan konfigurasi properties seperti diatas, sebuah item

akan diposisikan disebelah kiri bawah
10. Untuk lebih memahami relatif layout, tambahkan dua button
baru ke dalam layout, lalu ubah ke text mode, sesuaikan
dengan kodingan dibawah ini

Gambar 5. 7 Contoh Relatif Layout 2
11. Terlihat bahwa pada button 3 terdapat konfigurasi properties
sebagai berikut
android:layout_below = "@id/button"
ini berarti bahwa sesuai konfigurasi diatas, button 3 akan

diletakkan di sebelah kiri atas dan dibawah button 1
12. Sedangkan pada button 4 terdapat konfigurasi properties
sebagai berikut
android:layout_below = "@id/button"
ini berarti bahwa sesuai konfigurasi diatas, button 4 akan
diletakkan di sebelah kanan bawah dan diatas button 2

BAB 6
INTERAKSI ANTAR ACTIVITY (INTENT)
A. INTENT
Intent adalah sebuah jembatan penghubung yang digunakan
untuk perpindahan halaman antar activity dalam aplikasi. Suatu
activity dapat berpindah dari satu activity ke activity lain dengan
membawa data maupun tidak, bahkan intent dapat membuka
aplikasi lain seperti Gmail, GoogleMap, dll
Sebagai contoh, dalam sebuah halaman activity terdapat sebuah
button yang mana ketika user menekan tombol tersebut, maka
user bisa berpindah ke halaman activity lain, dapat membuka peta
atau dapat mengakses internal device seperti kamera.
startActivity() adalah sebuah method yang digunakan untuk
memulai sebuah activity lain. Untuk dapat memanggil methode
tersebut maka pengguna harus membuat object terlebih dahulu
dari class android.content.intent.
Secara umum Intent dibagi menjadi 2, yaitu :

1. Explicit Intent berfungsi untuk mengaktifkan activity yang
dibuat oleh user dalam satu aplikasi yang sama. Misalnya
seperti : Berpindah Activity.
2. Implicit Intent berfungsi untuk memanggil fungsi activity yang
sudah tersedia pada fungsi internal android seperti Kamera,
Dial Number, Open Browser dan lainnya.
Pemanggilan Intent secara explicit dilakukan dengan cara
menentukan nama Activity tujuan. Intent mempunyai dua
parameter, yaitu yang pertama adalah Context (tempat dimana
activity tersebut sedang aktif) dan berikutnya adalah destination
(activity yang akan dituju jika user melakukan sebuah aksi, misal
menekan button)
Intent intent = new Intent(this, NextActivity.class);

startActivity(intent);

putExtra() adalah suatu metode yang disediakan oleh Intent yang
digunakan untuk mengirimkan data pada activity yang dituju. Data
yang dikirimkan dapat berupa string, integer, double, float,
boolean, ArrayList, Char, array dll. Namun tidak semua tipe data
dapat dikirim menggunakan intent, contohnya tipe data berukuran
besar seperti bitmap atau file tidak dapat dikirim antar activity
melalui metode ini.
B. Cara Membuat Explicit Intent

Berikut ini adalah cara membuat Intent yaitu interaksi antara
halaman satu dengan yang lainnya
1. Buatlah sebuah project dengan nama INTENT-1
2. Bukalah main_activity.xml, pada bagian component tree
ubah constrain layout menjadi linear layout – vertical
seperti pada contoh jobheet sebelumnya
3. Buatlah 3 Button dengan nama Text dan nama Id seperti
dibawah ini
Gambar 6. 1 Tampilan Button
4. Ubahlah pada mode Text, pastikan code xml ketiga button

tersebut seperti dibawah ini
<Button
android:id="@+id/button_explicit"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_marginTop="150dp"

android:onClick="HandleExplicit"
android:text="EXPLICIT INTENT" />
<Button
android:id="@+id/button_implicit"
android:layout_centerHorizontal="true"
android:onClick="HandleImplicit"
android:text="IMPLICIT INTENT" />
<Button
android:id="@+id/button_extra"
android:onClick="HandleIntentExtra"
android:text="Intent with Extra" />
5. Bukalah file MainActivity.java buatlah pendeklarasian

variabel atau disebut juga pendeklarasian objek dan
buatlah pengenalan komponen seperti dibawah ini
Gambar 6. 2 Tampilan MainActivity

6. Buka file main_activity.xml pada bagian text, lalu pada tag
button tambahkan android:onClick="handleExplicit"
kemudian pindahkan cursor pada baris yang memuat kode
“handleExplicit” kemudian tekan tombol shortcut Alt +
Enter dan pilih Create 'handleExplicit(View view)' in
'MainActivity'. Android Studio akan menambahkan
secara otomatis method pada file MainActivity. Proses ini
digunakan untuk menambahkan logika pada Activity ketika
tombol ditekan.

7. Pada handler ini, tambahkan logika untuk membuka
ExplicitIntentActivity dengan menggunakan Intent
Intent explicit = new Intent(this,
Explicit_Intent.class);
startActivity(explicit);
8. Amati apakah terdapat eror ? ya, pastinya terdapat eror,

hal ini disebabkan karena class Explisit_intent belum
dibuat, oleh karena itu buatlah Activity baru yang bernama
Explicit_Intent, activity ini yang akan dipanggil ketika
button_explicit ditekan
9. Selanjutnya bukalah activity_explicit_intent.xml buatlah
Tampilan “Hallo ini halaman Explicit Intent” seperti
dibawah ini
Gambar 6. 3 Tampilan Halaman Explicit Intent
10. Jalankan program, maka akan tampil output seperti berikut

ini Hasil Output Explicit Intent

Gambar 6. 4 Hasil output Explicit Intent
C. Cara Membuat Implicit Intent

Android menyediakan aktivity bawaan agar user dapat mengakses
internal device seperti call, dialpad, camera, contact, browser, call
log, gallery, dll. Pemanggilan aktivity ini disebut Implicit Intent.
User bisa melakukannya dengan cara mendefinisikan aksi tertentu
yang umumnya menggunakan prefiks Action.
Dibawah ini merupakan contoh kode untuk pemanggilan Gallery
yang berisi gambar
Intent intent = new Intent(Intent.ACTION_PICK,
MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
Berikut cara untuk membuka suatu alamat website menggunakan

suatu browser tertentu :
1. Masih di project yang sama, Buka dan amati file
MainActivity.java dan activity_main.xml dalam project
Intent.

2. Pada tombol Implicit Intent tambahkan atribut
android:onClick="handleImplicitIntent", kemudian
generate handler menggunakan shortcut Alt + Enter.
3. Lengkapi dengan logika intent, untuk membuka suatu
halaman Facebook
public void HandleImplicit(View view) {
Intent implicit = new
Intent(Intent.ACTION_VIEW,
Uri.parse("http://www.facebook.com"));
startActivity(implicit);
}
4. Jalankan program maka akan tampil output seperti

dibawah ini Hasil Output Implicit Intent
Gambar 6. 5 Hasil Output Implicit Intent

D. Cara Mengirim Data Antar Activity
1. Masih di project yang sama, buatlah sebuah activity baru

yang bernama Intent_with_extra yang digunakan

sebagai halaman untuk memasukkan data dan
tambahkan activity baru dengan nama Tampil, yang
digunakan sebagai halaman untuk menampilkan data
sehingga struktur folder andorid keseluruhan sebagai
berikut :
Gambar 6.6 Struktur Folder
2. Buka fila activity_intent_with_extra.xml dan buatlah

tampilan seperti dibawah ini

Gambar 6. 7 Tampilan File activity_intent_with_extra.xml
Sesuaikan nama id yang dipakai dan nama text button.

Tampilan ini sama dengan tampilan pada praktikum
sebelumya, hanya saja pada praktikum sebelumnya
output text ditampilkan pada halaman itu sendiri,
sedangkan praktikum kali ini kita akan mencoba
menampilkan data ke activity lain yang dituju
3. Pada tombol Intent With Extra tambahkan atribut
android:onClick="WithPutExtra", kemudian generate
handler menggunakan shortcut Alt + Enter.
4. Secara otomatis akan dibuatkan fungsi WithPutExtra ()
pada Intent_with_extra.java kemudian lengkapi logika
intent untuk mengambil nilai dari EditTeks menggunakan
fungsi putExtra ()
public void WithPutExtra(View view) {
Intent explicit = new Intent(this,
Tampil.class);
explicit.putExtra("name",
nama.getText().toString());
startActivity(explicit);
}
5. Lengkapi pendeklarasian variabel dan pengenalan

komponen seperti berikut ini

Gambar 6.8 Tampilan Class Intent With Extra
6. Selanjutnya buka file activity_tampil.xml dan buatlah

TextView untuk menampilkan nilai yang dimasukkan dari
activity lain
Gambar 6. 9 Tampilan activity_tampil.xml
7. Kemudian buka file Tampil.java dan tambahkan code

berikut ke dalam fungsi OnCreate ()
TextView t = (TextView)
findViewById(R.id.tampil);

Bundle bundle = getIntent().getExtras();
String s = bundle.getString("name");
t.setText("HALLO " +s);
8. Amati dan analisa adakah perbedaan deklarasi object
dan pengenalan komponen pada code diatas (poin 7)
dengan code2 sebelumnya?
9. Jalankan program, maka akan keluar tampilan seperti
dibawah ini Hasil output Intent With Extra
Gambar 6.10 Tampilan Intent With Extra
SOAL
1. Modifikasi Program diatas sehingga bisa mengirimkan dan

menampilkan data berikut ke suatu Activity yang dituju
Nim :
Nama :
Kelas :

IPK :
nilaiMK1:
nilaiMK2 :
RATA2 =
E. Studi kasus Radio Button

1. Bukalah Project Intent-2 yang telah diberikan, amatilah
activity_main.xml dan buatlah fungsi untuk menghandle
masing-masing button pada activity_main.xml
Gambar 6.11 Membuat Fungsi handleRadioButton

2. Bukalah MainActivity.java buatlah intent untuk menuju
ke halaman yang dituju seperti dibawah ini
public void handleRadioButton(View view) {
Intent intent = new
Intent(this,Ekspedisi.class);
}
public void HandleListView(View view) {

Intent intent = new
Intent(this,ListView.class);
}
public void HandleDialogMessage(View view) {

Intent intent = new
Intent(this,DialogMessage.class);

}
3. Bukalah activity_ekspedisi.xml lalu drag and drop

RadioGroup terlebih dahulu dalam component tree,
selanjutnya drag and drop RadioButton ke dalam
RadioGrup yang telah dibuat sebelumnya sehingga
struktur komponen tree menjadi seperti dibawah ini
Gambar 6.12 Drag and Drop Radio Button

4. Bentuk tampilan RadioButton adalah vertikal,
bagaimana cara mengubahnya ke horizontal ? tulislah
pada laporan
5. Bukalah class expedisi.java buatlah deklarasi object
dari komponen-komponen yang digunakan seperti
berikut ini, untuk TextView tidak perlu di deklarasikan
karena hanya digunakan untuk menampilkan Text saja
private EditText dari, ke, berat;
private RadioGroup radio_group_1;
private RadioButton rb1,rb2,rb3;
private Button button_hitung;
6. Buatlah program untuk pengenalan komponen seperti

dibawah ini :
protected void onCreate(Bundle
savedInstanceState) {

setContentView(R.layout.activity_ekspedisi);
dari = findViewById(R.id.id_dari);
ke = findViewById(R.id.id_ke);
radio_group_1 =
findViewById(R.id.radio_group_1);
rb1 = findViewById(R.id.rb1);
berat = findViewById(R.id.id_berat);
button_hitung =
findViewById(R.id.button_hitung);
}
7. Buatlah fungsi HandleHitung () dengan cara sama pada

latihan sebelumnya untuk menghandle ketika button
Hitung di klik
Intent intent = new
Intent(this,TampilExpedisi.class);
Perintah tersebut digunakan untuk membuka class

TampilEkspedisi jika button hitung di klik
8. Masih dalam fungsi HandleHitung() buatlah perintah

untuk mengambil text dari EditText menggunakan fungsi
putEkstra()
intent.putExtra("key",
dari.getText().toString());
intent.putExtra("key2",
ke.getText().toString());
9. Untuk mengambil nilai yang dipilih pada RadioButton

gunakan fungsi getCheckedRadioButtonId() dimana
nomor indeks selalu dimulai dari 0
//membuat ID bagi radio button yang diklik
int selectedId =
radio_group_1.getCheckedRadioButtonId();
if (selectedId == -1) { //-1 di bawah 0,berarti

tidak ada yang dipilih.
//Perintah Toast.makeText digunakan untuk

menampilkan pesan

Toast.makeText(this, "Tidak ada yang
dipilih!", Toast.LENGTH_SHORT).show();
}
else{
RadioButton rb =
radio_group_1.findViewById(selectedId);
intent.putExtra("key4", rb.getText());
Toast.makeText(this, "Pilihan Anda adalah
"+ rb.getText(), Toast.LENGTH_SHORT).show();
10. Karena nilai yang didapatkan dari EditText defaultnya

berupa String, maka untuk berat harus di parsing terlebih
dahulu ke tipe data integer agar dapat diproses
perhitungan total biayanya, parsing tipe data
menggunakan perintah Integer.parseInt ()
int w =
Integer.parseInt(berat.getText().toString());
intent.putExtra("key3", w);
11. Bukalah activity_tampil_ekspedisi.xml buat TextView

seperti dibawah ini
Gambar 6.13 Halaman activity_tampil_ekspedisi.xml

12. Bukalah tampil_ekspedisi.java lakukan pendeklarasian
variabel dan pengenalan komponen
private TextView text1, text2, text3, text4, text5;
@Override
protected void onCreate(Bundle savedInstanceState)
{
setContentView(R.layout.activity_tampil_expedisi);
TextView tampil = findViewById(R.id.id_tampil);
text1 = findViewById(R.id.text1);
13. Kemudian masih didalam fungsi onCreate () tambahkan

perintah untuk mengambil data yang dimasukkan user
menggunakan Bundle dan gunakan “key” yang sama
pada saat putExtra ()
Bundle bundle=getIntent().getExtras();
String asal=bundle.getString("key");
String tujuan=bundle.getString("key2");
String paket=bundle.getString("key4");
int berat=bundle.getInt("key3");
14. Perintah berikut ini digunakan untuk menampilkan nilai

pada TextView yang telah dibuat
tampil.setText("Selamat Datang di JNP Express");

text1.setText("Kota Asal = " + asal);
text2.setText("Kota Tujuan = " + tujuan);
text3.setText("Jenis Paket = " + paket);
text4.setText("Berat = " + berat);
15. Untuk biaya, gunakan seleksi kondisi if..else if.. else

untuk menentukan tarif yang berbeda untuk paket
Express, Reguler, atau Ekonomi
int biaya;
if (paket.equalsIgnoreCase("Express")){
biaya = berat * 15000;
}
else if(paket.equalsIgnoreCase("Reguler")){
}
else{

}
text5.setText("Biaya = " + biaya );
16. Selesai, kemudian jalankan program maka akan muncul

tampilan sebagai berikut

Gambar 6.14 Hasil Output Studi Kasus Radio Button

F. Studi Kasus List View
1. Bukalah activity_list_view dan drag and drop

komponen widget ListView, jika tidak menemukan bisa
di search, sehingga tampil sebagai berikut
Gambar 6.1 Tampilan activity_list_view
2. ListView digunakan untuk menampilkan pilihan item

yang dapat dipilih oleh user
3. Bukalah ListView.java Lakukan pendeklarasian
komponen menggunakan perintah berikut
//Pola 1. Pendeklarasian/penginisialisasian
komponen
android.widget.ListView list_users;
4. Buatlah array users untuk menyimpan daftar kata yang

akan ditampilkan pada list view
String[] users = {
"Malang", "Kediri", "Surabaya", "Tulungagung", "Batu",
"Pasuruan", "Probolinggo", "Bojonegoro", "Gresik",
"Tuban", "Bandung", "Jakarta", "Semarang", "Jogja",
"Cirebon", "Klaten", "Sumedang", "Sukabumi",
"Bogor", "Banyuwangi", "Ngawi", "Madiun",
"Purwakarta", "Purbalingga", "Jember", "Garut”};

5. Array Adapter digunakan sebagai jembatan antara
array dan list view (atau recycler view) lakukan
pendeklarasian Array Adapter
ArrayAdapter arrayAdapter;
6. Pada fungsi onCreated () tambahkan perintah berikut

ini
@Override
protected void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.activity_list_view);
//Pola 2. Mengenali komponen
list_users = findViewById(R.id.list_users);
arrayAdapter = new ArrayAdapter
(this,android.R.layout.simple_list_item_1,users);
list_users.setAdapter(arrayAdapter);
list_users.setOnItemClickListener(new
AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View
view, int position, long id) {
String index =
list_users.getItemAtPosition(position).toString();
Toast.makeText(ListView.this, "Pilihan Anda adalah
: " + index, Toast.LENGTH_LONG).show();
}
7. Perintah Toast.makeText digunakan untuk
menampilkan text selama beberapa menit dan akhirnya
menghilang, tergantung kategori yang dipilih
LENGHT_LONG atau LENGHT_SHORT, Teks akan
ditampilkan pada bagian bawah atau atas layar
smartphone
8. Jalankan program, maka akan muncul tampilan seperti
berikut ini, kemudian pilih button List View maka akan
tampil pilihan kota, ketika user memilih Tulungagung
maka akan muncul toast dibawah layar seperti yang
ditandai pada kotak merah

Gambar 6.2 Hasil Output Studi Kasus List View

BAB 7
FRAGMENT
A. URAIAN MATERI FRAGMEN

Fragmen adalah bagian dari antarmuka pengguna dalam
sebuah FragmentActivity. Fragmen yang terdapat dalam
android dapat dikombinasikan maupun digunakan Kembali.
Fragmen membuat UI yang telah dibuat menjadi dinamis dan
fleksibel, dimana pengembang dapat mengombinasikan
beberapa fragmen dalam satu aktivitas untuk membuat
sebuah antarmuka yang multi-panel dan menggunakan
Kembali sebuah fragmen dalam aktivitas lainnya.
Pengembang dapat menganggap fragmen sebagai sebuah
bagian modular dari aktivitas, dimana fragmen ini memiliki daur
hidup sendiri, menerima kejadian masukan sendiri, dan bisa
dilakukan proses penambahkan atau penghapusan saat
aktivitas berjalan. (semacam "subaktivitas" yang bisa
digunakan kembali dalam aktivitas berbeda).
Sebuah fragmen memiliki siklus proses sendiri, mengelola dan

menentukan tata letaknya sendiri, serta mampu menangani
peristiwa inputnya sendiri. Fragmen tidak mempu berjalan
sendiri, harus dihosting atau tertanam oleh aktivitas maupun
fragmen lainnya, sehingga siklus hidup fragmen ditentukan
atau dipengaruhi oleh siklus hidup aktivitas host dan fragmen
yang diterimanya memiliki input peristiwa sendiri.
Sebagai contoh saat aktivitas dihentikan sementara, semua

fragmen di dalamnya juga secara otomatis dihentikan
sementara, dan apabila aktivitas dihapus, semua fragmen juga
ikut terhapus. Namun, saat aktivitas berjalan (dalam status
daur hidup dilanjutkan), memanipulasi setiap fragmen secara
terpisah dapat dilakukan, seperti menambah atau
menghapusnya.
Dalam aplikasi Android, kita dapat menggunakan lebih dari

satu fragmen dalam satu aktivitas guna membuat UI Multi-
Panel dan juga dapat menggunakan satu fragmen dalam

beberapa aktivitas. Seperti yang ditampilkan dalam Gambar
89.
Fragmen Manager memiliki fungsi sebagai sarana

maupubnpenanggung jawab untuk menambah, menghapus
maupun mengganti fragmen pada waktu berjalan di aktivitas
manapun.
Ketika proses penambahan fragmen sebagai bagian dari

layout aktivitas, fragmen tersebut terletak dalam ViewGroup di
hirarki tampilan aktivitas tersebut dan fragmen akan
mendefinisikan layout tampilannya sendiri.
Fragmen menyediakan modularitas dan fungsi untuk

penggunaan Kembali ke dalam UI aktifitas, memungkinkan
pengguna untuk membagi UI kedalam bagian-bagian yang
terpisah. Aktifitas adalah tempat ideal untuk menempatkan
elemen global di bagian sekitar UI aplikasi, umumnya
digunakan sebagai panel navigasi. Fragmen cocok digunakan
untuk mengelola UI dari satu ataupun Sebagian layer.
Misalkan terdapat sebuah aplikasi yang bisa menampilkan

daftar list disebelah kiri layar, dan fragmen lainnya untuk
menampilkan. Isi berita di sebelah kanan layar. Kedua
fargmen ini muncul dalam satu aktivitas, berdampingan, dan
masing-masing fragmen memiliki metode callback daur hidup
serta menangani kejadikan dari masukan penggunanya.
Tujuannya adalah agar pengguna bisa memilih list menu dan
membaca beritanya dalam sebuah aktivitas yang sama.
Setiap fragmen juga harus didesain sebagai komponen

modular dan bisa digunakan Kembali. Setiap fragmen
mendefinisikan layout dan perilakunya dengan cara callback
daur hidupnya sendiri. Pengembangd apat memasukkan satu
fragmen dalam banyak aktivitas, sehingga desainnya harus
dapat digunakan Kembali dan mencegah memanipulasi satu
fragmen dari fragmen lainnya secara langsung. Hal ini sangat
penting untuk diperhatikan karena fragmen modular yang telah
dibuat sebelumnya dapat mengubah kombinasi fragmen untuk
ukutan layar yang berbeda

Berbagai macam peralatan android misalnya tablet dan
smartphone memiliki ukuran layar ang berbeda-beda, pada
layer yang memiliki ukuran besar, aplikasi dituntut harus dapat
menampilkan panel aplikasi secara statis dimana menu
navigasi tersebut nyaman dilihat oleh pengguna, sedangkan di
layer yang lebih kecil, aplikasi tentu saja tidak dapat
menampilkan seluruh ukuran layer tersebut, dikarenakan
resolusi ataupun ukurannya terlalu kecil, namun tetap dituntut
untuk dapat menampilkan menu navigasi yang lebih kecil,
dengan karakteristik tetap nyaman digunakan oleh pengguna
serta daftar tata letak linear harus rapi. Walau ada beberapa
bagian yang tidak ditampilkan, dan dalam menampilkannya
perlu menekan tombol secara khiusus. Mengelola semua
varian tersebut dalam sebuah aktivitas merupakan tugas yang
cukup sulit. Pemisahan beberapa elemen navigasi dari sebuah
konten dapat mempermudah proses pengelolaan fragmen,
kemudian aktivotas tersebut bertugas menampilkan UI
navigasi yang benar Ketika fragmen menampilkan daftar
dengan tata letak yang sesuai. Dua versi layar yang sama,
namun memiliki ukuran layer yang berbeda ditampilkan dalam
Gambar 7.1
Gambar 7.1 Contoh Fragmen di Android

Sebelah kiri, merupakan contoh layar besar yang berisi panel
navigasi dan dikontrol olej aktivitas serta list daftar pertak yang
dikontrol oleh fragmen. Di sisi kanan, sebuah layar berukuran
kecil berisi menu navigasi yang posisinya ada di bawah dan

dikontrol oleh aktivitas, serta daftar linear yang dikontrol oleh
fragmen
Gambar 7.2 Contoh Fragmen di Android
Membagi sebuah UI menjadi lebih dari satu fragmen akan

memudahkan pengembang aplikasi dalam mengubah tampilan
aktivitas Ketika runtime. Pengembang aplikasi dapat
menggunakan beberapa instance dari sebuah class fragmen
yang sama dalam aktivitas yang sama, di beberapa aktivitas
yang dapat juga sebagai turunan dari fragmen lainnya.
Pengembang hana perlu menyediakan fragmen dengan logika
yang diperlukan untuk mengelola UI aplikasi. Disarankan
menghindari dependensi atau manipulasi antara fragmen.
B. MEMBUAT FRAGMEN
Dalam membuat fragmen, subclass fragment harus dibuat terlebih
dahulu. Kelas fragment memiliki kode yang mirip seperti Activity
dan kelas ini juga memiliki metode callback yang mirip dengan
Activity, seperti onCreate(), onStart(), onPause(), dan onStop().
Saat mengkonversi aplikasi Andoid untuk menggunakan fragmen.
Memindahkan kode dari metode callback aktivitas ke masing-
masing metode callback fragmen dapat dilakukan, dimana
umumnya metode daur hidup berikut perlu diimplementasikan.

1. onCreate: Sistem memanggil metode ini saat membuat
fragmen. Dalam implementasinya, inisialisasi komponen
penting dari fragmen yang ingin dipertahankan ketika
fragmen dihentikan sementara atau dihentikan, kemudian
dilanjutkan perlu diinisialisasi terlebih dahulu.
2. onCreateView(): Sistem akan memanggil metode ini ketika

fragmen membuat ataupun menggambar antarmuka
penggunanya untuk yang pertama kali. Dalam
menggambar UI fragmen, mengembalikan View dari
metode ini yang menjadi root-layout fragmen perlu
dilakukan. Hasil yang dikembalikan bisa berupa null jika
fragmen tidak menyediakan UI.
3. onPause(): Sistem akan memanggil metode ini sebaga

sebuahi indikasi pertama bahwa pengguna sedang
meninggalkan fragmen, (walau itu tidak selalu berarti
fragmen sedang dimusnahkan). Di sinilah biasanya
perubahan yang harus dipertahankan di luar sesi
pengguna saat ini harus diikat (karena kemungkinan
pengguna tidak akan kembali).
Umumnya aplikasi harus menerapkan setidaknya tiga metode

diatas untuk setiap fragmen, namun terdapat beberapa metode
callback lain yang juga harus digunakan untuk menangani
berbagai tahap daur hidup fragmen. Semua metode callback daur
hidup dibahas lebih detail di bagian Menangani Daur Hidup
Fragmen. Metode - metode fragmen lainnya adalah sebagai
berikut:
4. onAttach() metode ini panggil pertama kali bahkan

sebelum onCreate() callback dan setelah fragmen telah
dipasangkan ke activity.
5. onActivityCreated() Metode ini dipanggil setelah Activity

onCreate() Callback telah selesai dieksekusi. Metode ini
adalah indikasi activity tersebut telah menyelesaikan
eksekusi sebelum kita mencoba mengakses dan
memodifikasi elemen UI dari activity secara bebas.

6. onStart() metode yang dipanggil setelah fragmen terlihat
pada activity.
7. onResume() metode ini dipanggil ketika pengguna

berinteraksi dengan fragmen dalam activity setelah Activity
onResume() callback.
8. onStop() metode ini dipanggil ketika fragmen tidak lagi

berinteraksi dengan pengguna baik karena aktivitasnya
dihentikan atau operasi fragmen mengubahnya dalam
activity.
9. onDestroy() metode ini dipanggil untuk memungkinkan

fragmen membersihkan resources yang terkait dengan
view yang ada pada activity.
10. onDestroyView() metode ini dipanggil untuk melakukan

pembersihan akhir dari status fragmen.
11. onDetach() metode ini dipanggil ke fragmen yang tidak

lagi dikaitkan dengan aktivitasnya.
12. onSaveInstanceState() callback ini dipanggil dimana

pengguna diizinkan untuk menyimpan beberapa data
mengenai peristiwa fragmen tepat sebelum aplikasi di
pause, sehingga pengguna kembali ke aplikasi mereka
dengan mendapatkan data yang disimpan. Disini
dibutuhkan Bundle sehingga pengguna dapat menyimpan
data sebagai key atau nilai.
C. Mengelola Daur Hidup Fragmen

Mengelola daur hidup fragmen mirip dengan mengelola daur hidup
aktivitas, dimana fragmen bisa berada dalam tiga status:
1. Dilanjutkan, dimana fragmen yang terlihat dalam aktivitas

yang berjalan memiliki activity state: Created, dan
Fragment Callbacks yang berjalan sesuai urutan adalah:
onAttach() – onCreate() – onCreateView() –
onActivityCreated().
2. Dihentikan sementara, dimana aktivitas lain berada di latar

depan dan memiliki focus, namun aktivitas tempat fragmen
berada masih terlihat. (Aktivitas tidak menutupi seluruh

layar atau latar depan depan masih terlihat Sebagian)
Activity state yang ada di dalam proses ini adalah Started,
Resumed dan Paused. Fargemnt Callbacks yang berjalan
sesuai urutan adalah: onStart() – onResume() –
onPause().
3. Dihentikam, dimana fragmen tidak terlihat, aktivitas host

telah dihentikan atau fragmen telah dihapus dari aktivitas,
namun ditambahkan ke back-stack. Pada saat ini, fragmen
yang dihentikan masih hidup, dimana semua status dan
informasi anggota masih disimpan oleh sistem). Namun
fragmen tidak terlihat lagi oleh pengguna dan akan
dimatikan jika aktivitas dimatikan. Aktivity State dalam
kondisi ini adalah: Stopped dan Destroyed. Sedangkan
Fragment Callbacks yang berjalan sesuai urutan adalah:
onStop() – onDestroyView() – onDestroy()- onDetach().
D. Kode Fragmen
Sebelum Fragmen diperkenalkan, pengembang hanya dapat
menampilkan hanya satu activitas di layar pada satu waktu
tertentu. Pengguna tidak dapat membagi layar dan mengontrol
bagian yang berbeda secara terpisah. Dengan bantuan Fragmen,
pengembang dapat membagi layar di berbagai bagian dan
mengontrol bagian-bagian yang berbeda secara terpisah.
Dengan menggunakan Fragmen, pengembang dapat membentuk

beberapa Fragmen dalam satu activitas. Fragmen memiliki event,
layout, dan status mereka sendiri. Semua hal tersebut
memberikan fleksibilitas dan juga meniadakan limitasi dalam
activitas tunggal di layar pada suatu waktu. Kode Fragmen dasar
dalam XML ditampilkan dalam Gambar 7.3.
Gambar 7.3 Kode Fragment dalam XML

E. Cara membuat Kelas Fragmen di Android Studio
Langkah pertama adalah extend kelas Fragmen, lalu override
method status utama, lalu memasukkan logic kode aplikasi, mirip

dengan cara menggunakan kelas activity. Saat membuat
Fragment callback onCreateView () harus digunakan dalam
menentukan layout dan menjalankan Fragment.
Gambar 7.4 Logic Kode Fragmen
Parameter "inflater" adalah "LayoutInflater" yang digunakan untuk

melakukan "inflate layout". Parameter "container" adalah parent
ViewGroup (dari layout activity) tempat susunan Fragmen yang
akan disisipkan.
Parameter "savedInstanceState" adalah "Bundle" yang

menyediakan data tentang "instance" sebelumnya dari Fragmen.
Method inflate() memiliki tiga argumen, pertama adalah "resource
layout" yang ingin kita inflate, kedua adalah "ViewGroup" sebgai
parent dari layout yang dilakukan inflate. Parameter ketiga adalah
nilai boolean yang mengindikasikan apakah layout yang dilakukan
inflate haruskah di attach ke ViewGroup (parameter kedua).
F. Implementasi Fragmen di Android Studio

Langkah-langkan dalam mengimplementasikan Fragmen di
Android Studio diantaranya:
(1) Membuat Proyek baru, silahkan memberi nama dengan

FragmenNamaKalian

(2) Membuka res>layout>activity_main atau main.xml dan
silahkan modifikasi kode didalamnya seperti dalam
Gambar 7.5 berikut:
Gambar 7.5 Langkah-Langkah membuat Fragmen Part 1
4. Membuka MainActivity.java, dalam Langkah ini silahkan

buka MainActivity dan tambahkan kode untuk inisiasi
tombol. Setelah itu buat event "setOnClickListener" di
kedua Button. Pada klik Tombol Pertama kita replace "First
Fragment " dan saat klik Tombol Kedua kita akan replace
"Second Fragment" dengan layout (FrameLayout). Untuk
mengganti Fragment dengan FrameLayout pertama-tama
kita buat Fragment Manager dan kemudian mulai transaksi
menggunakan Fragment Transaction dan akhirnya replace
Fragment dengan layout yaitu FrameLayout. Proses ini
ditampilkan dalam gambar 7.6 berikut:

Gambar 7.6 Langkah-Langkah membuat Fragmen Part 1
5. Membuat dua fragmen dengan lahkah-langkah: klik kanan

pada folder package dan buat class kemudian beri nama
class pertama sebagai "FirstFragment" dan beri nama
class kedua sebagai "SecondFragment" dan tambahkan
kode berikut di masing-masing clas fragment. Gambar 95
adalah kode pada FirstFragment.class dan Gambar 96
adalah kode pada SecondFragment.class. Proses yang
terdapat di Gambar 7.7 yaitu: pertama kita inflate layout
dan mendapatkan referensi terhadap Button object.
Setelah itu lakukan event setOnClickListener di Button
sehingga setiap kali pengguna mengklik tombol. Pesan
"First Fragment" ditampilkan di layar dengan menggunakan
Toast.

Gambar 7.7 Kode FirstFragment.class
Gambar 7.8 Kode SecondFragment.class

6. Membuat dua xml layout. Masing-masing diberi nama
sebagai fragment_first dan fragment_second.
Tambahkan kode berikut di file masing-masing. Proses
menambahan kode titampilkan dalam Gambar 7.9 untuk
fragment_first.xml dan Gambar 7.10 untuk
fragment_second.xml

Gambar 7.9 Kode Fragment_First.xml
Gambar 7.10 Kode fragment_second.xml

7. Membuka res > value > colors.xml. Proses dalam tahap ini
adalah mendefinisikan warna yang akan digunakan dalam
file xml. Seperti yang ditampilkan dalam Gambar 7.11

Gambar 7.11 Kode Colors.xml
8. Membuka AndroidManifest.xml. Dalam langkah ini,

pengembang membuka buka file Android Manifest yang
sebenarnya tidak perlu dilakukan pengeditan sama sekali
karena aplikasi ini hanya berisi satu Activity yaitu
MainActivity, yang sudah didefinisikan didalamnya. Dalam
contoh proyek ini, memang membuat dua fragment tetapi
kedua fragment tersebut tidak perlu didefinisikan dalam
manifest karena fragment adalah bagian dari activity.
Jalankan aplikasikasi dan contoh dari kegiatan ini
ditampilkan dalam Gambar 7.12 dan 7.13.
Gambar 7.12 Hasil Uji Coba Fragmen Di Android Part 1

Gambar 7.13 Hasil Uji Coba Fragmen Di Android Part 2

BAB 8
AKSES GOOGLE MAPS, GPS
A. Persiapan Instalasi
Bab ini akan menampilkan Google Maps dengan menunjuk pada
koordinat yang telah kita tentukan. Namun sebelum menampilkan
Maps, ada beberapa tahapan yang harus dilakukan, yaitu:
Instalasi Google Play Service dan mendaftar pada Google Maps
API untuk mendapatkan API Key.
Silahkan download project yang telah disediakan pada link berikut
Ekstrak dan buka proyek Android tersebut, pastikan bahwa
Google Play services telah terinstall pada Android Studio dengan
cara buka: Tools > SDK Manager,
maka akan muncul kotak dialog seperti pada gambar di bawah ini.
Pilih tab SDK Tools dan ceklis pada Google Play Services, jika
statusnya Not Installed, klik Apply pada bagian bawah untuk
memulai proses instalasi. Proses dari langkah ini ditampilkan
dalam Gambar 8.1.
Gambar 8.1 Instalasi Google Play Service

B. Membuat API Key
API key diperlukan untuk mengakses server Google Maps. Key ini
bersifat gratis dan dapat digunakan dengan aplikasi apa pun.
Tahapan untuk membuat API Key adalah sebagai berikut:
1. Kunjungi link berikut: [Google developer console]
(https://console.developers.google.com/), kemudian login
menggunakan email gmail yang telah dimiliki. Satu akun
gmail hanya bisa mendapatkan satu API key.
2. Membuat project baru dengan cara klik Create pada bagian
dashboard, atau melalui dropdown Select a Project. Proses
ini ditampilkan dalam Gambar 8.2 dan Gambar 8.3 Pada
halaman New Project, isikan nama project dan lokasi,
kemudian klik tombol Create.
Gambar 8.2 Membuat Project Baru di Google API Part 1
3. Klik link ENABLE APIS AND SERVICES pada dashboard,

dan pilih Maps SDK for Android. Proses ini ditampilkan
dalam Gambar 8.4.
4. Klik tombol ENABLE . Setelah itu pilih tab Credentials,
proses ini ditampilkan dalam Gambar 8.5.

5. Klik Create Credentials pada dropdown, dan pilih api key

untuk membuat key. Proses ini ditampilkan dalam Gambar
8.6. Maka akan muncul popup bahwa API key telah berhasil
dibuat.
6. Pada bagian Restrict and rename API key, pilih Android
apps, dan selanjutnya simpan perubahan. Proses ini
7. Setelah menyimpan pengaturan, copy API Key untuk
digunakan di tahap selanjutnya. Proses ini ditampilkan
dalam Gambar 8.8.

Gambar 65:

Gambar 66:

C. Menambahkan Kunci API ke Aplikasi
Pengguna tidak dipebolehkan memasukkan kunci API ke dalam
sistem kontrol versi, jadi disarankan untuk menyimpan kunci
tersebut dalam file local.properties, file ini terletak di direktori
utama project. Informasi selengkapnya tentang
file local.properties, dapat dipelajari dalam link File properti
Gradle. Teknik Gradle berikut menunjukkan cara menyimpan
kunci API dalam file local.properties agar dapat direferensikan
dengan aman oleh aplikasi pengguna.
Langkah-langkah untuk menambahkan kunci API adalah :
1. Buka local.properties di direktori tingkat project, lalu
tambahkan kode berikut ke file.
Ganti YOUR_API_KEY dengan kunci API. Ditampilkan
dalam Gambar 8.9.
Gambar 8.9 Menambahkan Kunci API ke Aplikasi Part 1
2. Pada file build.gradle di tingkat aplikasi, tambahkan kode

ini dalam elemen defaultConfig. Hal ini memungkinkan
Android Studio membaca kunci Maps API dari
file local.properties pada waktu build, lalu memasukkan
variabel build mapsApiKey ke manifes Android. Proses ini

3. Dalam file AndroidManifest.xml, tambahkan potongan
kode berikut sebagai turunan dari elemen application.
Proses ini ditampilkan dalam Gambar 8.11.
4. Catatan: Membatasi Kunci API akan meningkatkan

keamanan aplikasi dengan memastikan hanya permintaan
sah yang dibuat dengan Kunci API. Sebaiknya ikuti
petunjuk untuk menetapkan pembatasan pada Kunci API.
Untuk informasi selengkapnya, lihat disini, namun pada
Latihan saat ini, belum wajib untuk diterapkan
D. Menampilkan Maps pada Android Studio
Proses ini memiliki beberapa Langkah, diantaranya adalah:
1. Silahkan Cek MapsMarkerActivity.Java: lengkapi apabila
terdapat coding yang kurang. Penjelasan lebih lanjut dapat
dilihat dalam Gambar 8.12 dan Gambar 8.13
Gambar 8.12 Menampilkan Maps pada Android Studio Part 1
2. Menambahkan Kunci API ke dalam aplikasi: Edit

file gradle.properties project. Tempelkan kunci API ke nilai
properti GOOGLE_MAPS_API_KEY. Saat membuat aplikasi,
Gradle menyalin kunci API ke dalam manifes Android
untuk aplikasi tersebut. Proses ini ditampilkan dalam
Gambar 8.14.

3. Jika default program di atas dijalankan, maka akan muncul

Google Maps dengan maker yang mengarah secara
default ke Sydney, seperti pada Gambar 8.15 berikut:

4. Silahkan melakukan pengeditan kode tersebut sehingga
dapat menampilkan lokasi tertentu seperti gambar berikut:
Contoh dalam Gambar 8.16: alun2 Batu. Cara
mendapatkan latitude dan longitude dapat membaca
artikel berikut.

E. Memahami Kode
Bagian ini akan menjelaskan perihal yang paling signifikan dari
sebuah aplikasi MapWithMarker untuk membantu memahami
cara membuat aplikasi yang serupa.
1. Memeriksa manifes Android: Silahkan membuka file
AndroidManifest.xml di Aplikasi, tambahkan elemen meta-
data untuk meletekakkan versi layanan Google Play yang
digunakan dalam mengkompilasi Aplikasi. Bagian ini
dijelaskan dalam Gambar 8.17
Gambar 8.17 Menyematkan Kode di Meta-data Part 1

2. Menambahkan elemen meta-data yang merupakan kunci
API yang telah dibuat sebelumnya. Petakan nilai untuk
kunci API ke dalam string google_maps_key saat
membuat aplikasi, Gradle akan menyalin kunci API dari
file gradle.properties project tang telah dibuat ke nilai
string. Proses ini ditampilkan dalam Gambar 8.18

Gambar 8.18 Menambahkan Kode di Meta-data Part 2
3. Untuk melihat bagaimana kunci API dipetakan ke nilai

string, silahkan perhatikan build.gradle aplikasi yang telah
dibuat. File build.gradle ini berisi baris yang ditampilkan
dalam Gambar 8.19 yang memetakan
string google_maps_key ke dalam property gradle
GOOGLE_MAPS_API_KEY.
Gambar 8.19 Pemetaan Kunci API ke Nilai String
4. Contoh Manifest Lengkap akan ditampilkan dalam

Gambar 8.20 dan Gambar 8.21 Berikut:
Gambar 8.20 Kode Manifes Part 1

Gambar 8.21 Kode Manifes Part 2

BAB 9
Akses Internal Device Kamera
A. Pendahuluan
Kamera merupakan salah satu perangkat keras pada Android dan
dapat diakses dalam pengembangan aplikasi mobile. Android
menyediakan akses penuh ke perangkat keras kamera.
Kerangka kerja Android mencakup dukungan untuk berbagai
kamera dan fitur kamera yang tersedia di perangkat,
memungkinkan untuk mengambil gambar di aplikasi. Lembar kerja
ini membahas tentang cara mengakses kamera dan mengambil
gambar dari aplikasi kamera yang dibuat.
Catatan: buku ini menjelaskan kelas android.hardware.camera,
yang sebenarnya sudah tidak digunakan lagi. Untuk kelas kamera
yang lebih baru terdapat camera2 dan cameraX. Namun
penggunaannya lebih sulit untuk dipelajari, oleh karena itu yang
digunakan adalah kelas camera.
B. Persiapan
Sebelum mengaktifkan aplikasi untuk menggunakan kamera pada
perangkat Android, perhatikan beberapa hal berikut :
1. Camera – Smartphone yang digunakan harus memiliki
minimal 1 kamera yang dapat diakses.
2. Kelas Kamera yang digunakan,
android.hardware.camera sudah kuno dan sudah tidak
disupport oleh android (deprecated) oleh karena itu,
tampilan pada android studio dicoret namun tetap dapat
digunakan.
3. Izin untuk menggunakan kamera dan penyimpanan

harus disetujui agar aplikasi dapat digunakan.
C. Mengembangkan aplikasi kamera

Langkah – Langkah umum untuk mengembangkan aplikasi
kamera adalah sebagai berikut :

1. Memeriksa & Meminta Izin
2. Mendeteksi dan Mengakses Kamera - Buat kode untuk
meminta akses dan memeriksa keberadaan kamera.
3. Membuat Class Preview - Buat class preview kamera
yang memperluas SurfaceView dan mengimplementasikan
antarmuka SurfaceHolder. Class ini mempreview gambar
langsung dari kamera.
4. Membuat Tata Letak Preview - Setelah memiliki class
preview kamera, buat tata letak tampilan yang
menggabungkan preview dan kontrol antarmuka pengguna
yang diiinginkan.
5. Menyiapkan listener untuk Pengambilan Foto -
Hubungkan listener untuk kontrol antarmuka guna memulai
pengambilan gambar atau video sebagai respons terhadap
tindakan pengguna, seperti menekan tombol.
6. Mengambil dan Menyimpan File - Siapkan kode untuk
mengambil gambar atau video dan menyimpan hasilnya.
7. Melepas Kamera - Setelah menggunakan kamera, aplikasi
harus dirilis dengan benar untuk digunakan oleh aplikasi
lain.
Hardware kamera adalah sumber daya bersama yang harus
dikelola dengan hati-hati agar aplikasi tidak bertabrakan dengan
aplikasi lain yang mungkin juga ingin menggunakannya. Bagian
berikut membahas cara mendeteksi hardware kamera, cara
meminta akses ke kamera, cara mengambil gambar atau video,
dan cara melepas kamera setelah aplikasi selesai
menggunakannya.
Perhatian: Ingatlah untuk melepas objek Camera dengan
memanggil Camera.release() setelah aplikasi selesai
menggunakannya! Jika aplikasi tidak merilis kamera dengan
benar, semua upaya berikutnya untuk mengakses kamera,
termasuk yang dilakukan oleh aplikasi itu sendiri, akan gagal dan
dapat menyebabkan aplikasi atau lainnya error.
1. Buat New Project, Beri nama Camera_1, Gunakan minimum
API 21 keatas (21+) agar dapat menggunakan semua fitur

Gambar 9.1 Konfigurasi Project Baru
2. Menambahkan Izin
Langkah pertama yang perlu dilakukan adalah menambahkan
izin untuk penggunaan kamera, dan izin untuk melakukan
penyimpanan gambar atau video ke dalam perangkat pada file
AndroidManifest.xml
Gambar 9.2 Izin pada AndroidManifest.xml

Sehingga tampilan AndroidManifest.xml Menjadi seperti berikut

Gambar 9.3 Tampilan AndroidManifest.xml setelah ditambahkan
izin
3. Memeriksa Izin
Agar mendapatkan izin untuk menggunakan kamera, pada
saat aplikasi pertama kali di buka, perlu ditambahkan
permintaan izin untuk penggunaan kamera dan pengaksesan
storage (menyimpan file).
Tambahkan sebuah method boolean untuk meminta izin
dengan nama cekIzinDitolak() pada file MainActivity.Java
Gambar 9.4 Pengecekan Izin dalam program

Method cekIzinDitolak() akan mengembalikan nilai berupa
true jika izin belum di berikan, dan false jika sudah. dan
PERMISSION adalah sebuah Variabel String Array yang berisi
izin apa saja yang mau diminta.
Gambar 9.5 Kode Permissions untuk mengecek izin

Dimana izin yang akan diminta yaitu untuk penggunaan
camera dan penyimpanan.
Panggil callBack onResume, dan tambahkan code berikut
untuk menggunakan method yang sudah di buat sebelumnya.
Gambar 9.6 Kode untuk method callback onResume

Pada saat callback onResume() dipanggil, aplikasi akan
melakukan pengecekan izin, dan jika izin belum diberikan,
akan memanggil fungsi requestPermissions() yang akan
meminta izin kepada pengguna. Dan REQUEST_CODE
adalah variable int yang berisi code yang digunakan sebagai
code untuk melakukan request.
4. Mengakses kamera
Untuk mengakses camera, langkah pertama yang perlu
dilakukan yaitu mendapatkan objek Camera, Untuk itu fungsi
Camera.open() perlu dipanggil. Dan untuk memudahkan
penggunaan, buat sebuah method Camera dengan nama
getCamera()

Gambar 9.7 Fungsi Untuk memanggil kamera pertama kali
Memanggil Camera.open() akan memunculkan error/exception

jika kamera sudah digunakan oleh aplikasi lain, Oleh karena
itu ditambahkan dalam blok try-catch dan akan menampilkan
sebuah Toast jika kamera tidak dapat diakses.
Keterangan : Fungsi Camera.open() dapat diberi sebuah

parameter untuk memilih kamera berupa integer jika kamera
yang tersedia lebih dari satu.
Contoh : Camera.open(1); //untuk menggunakan kamera
depan
Untuk memanggil fungsi getCamera() panggil fungsi
getCamera pada callback OnResume dan masukan pada
sebuah variabel Camera dengan nama mCamera
Gambar 9.8 Fungsi getCamera()

Variabel mCamera adalah sebuah variable Camera yang diisi
dengan null untuk sementara.

Perlu diingat bahwa setiap pemanggilan variable Camera,
yang digunakan(di import) adalah android.hardware.Camera
Gambar 9.9 Import library android.hardware.camera
5. Membuat Preview Kamera

Agar pengguna dapat mengambil gambar atau video secara
efektif, mereka harus dapat melihat apa yang dilihat kamera
perangkat. Class preview kamera adalah SurfaceView yang
dapat menampilkan data gambar langsung yang berasal dari
kamera, sehingga pengguna dapat membingkai dan
mengambil gambar atau video.
6. Class Preview
Untuk mulai menampilkan preview, diperlukan class Preview.
Preview memerlukan implementasi
android.view.SurfaceHolder.Callback, yang digunakan untuk
membuat dan menutup tampilan kamera.
Tambahkan Class Preview berikut pada mainActivity sebagai
local Class.

Class yang dibuat akan dikenali sebagai error karena class
yang mengimplementasikan SurfaceHolder.Callback wajib
memiliki implementasi method surfaceCreated(),
surfaceChanged(), dan surfaceDestroyed()
Untuk memengimplementasikan method tersebut, klik lampu
merah pada bagian yang error / klik alt+enter
Gambar 9.10 Implement method (1)

Lalu pilih implement methods, pilih ketiga method lalu klik OK

Maka ketiga method tersebut akan secara otomatis
diimplementasikan

Kemudian tambahkan lagi method constructor dengan

menekan tombol lampu merah sekali lagi
Gambar 9.13 Create Constructor (1)

Pilih Create constructor matching super
Gambar 9.14 Create Constructor (2)

Dan pilih pilihan pertama lalu klik tombol Ok, dan ubah method
Constructor yang dibuat dengan menambahkan parameter
Camera,

Dan isikan code berikut untuk menambahkan SurfaceHolder
dan Kamera
Gambar 9.15 Menambahkan SurfaceHolder Camera
Dimana surfaceHolder digunakan untuk memanggil fungsi

ketika preview di buat ,dirubah atau ditutup.
Lalu pada method surfaceCreated, tambahkan code berikut
untuk mengatur tampilan camera.
Gambar 9.16 Method SurfaceCreated
Dimana Fungsi :
• setPreviewDisplay digunakan untuk menentukan tampilan
preview
• startPreview untuk menampilkan tampilan preview
Camera
• dan setDisplayOrientation digunakan untuk mengatur
orientasi kamera

Fungsi diletakan pada blok try-catch agar ketika camera tidak
dapat digunakan aplikasi akan menampilkan toast
pemberitahuan.
Method surfaceChanged digunakan untuk mengatur jika

preview camera yang diinginkan dapat berubah tampilan atau
berubah orientasi nya (rotate). Untuk sekarang biarkan
kosong.
Method surfaceDestroyed akan dipanggil ketika tampilan

preview ditutup, dan diisi dengan camera.Release() atau
menutup Camera agar dapat digunakan pada aplikasi lain.
Gambar 9.17 Method SurfaceDestroyed

Class Preview yang telah dibuat sebelumnya, harus diletakan
dalam suatu komponen View yang nantinya digunakan
sebagai tempat untuk mengatur tampilan kamera. Dan dalam
contoh ini, komponen yang digunakan adalah FrameLayout,
yang digunakan sebagai Container untuk kelas preview
kamera.
Dan tambahkan sebuah Imagebutton yang nantinya digunakan

untuk shutter camera.

Dimana android:src diisi dengan gambar camera yang perlu
ditambahkan.
Gambar 9.18 Tampilan Awal FrameLayout untuk Camera
Lalu pada fungsi onResume, tambahkan class preview ke

dalam komponen FrameLayout yang telah dibuat sebelumnya

Dimana preview adalah variable objek dari local class preview
yang telah dibuat sebelumnya.
Dan frameLayoutPreview adalah komponen frameLayout
Sehingga method onResume menjadi seperti berikut
Gambar 9.19 Method OnResume
Coba Jalankan dan lihat apakah camera telah dapat

digunakan.
7. Mengambil Foto
Setelah membuat class preview dan tata letak tampilan untuk

menampilkannya, Aplikasi siap digunakan untuk mengambil
gambar. Untuk mengambil gambar, gunakan metode
Camera.takePicture(), metode ini mengambil tiga parameter
ayng menerima data dari kamera. Untuk menerima data dalam
format JPEG, harus diimplementasikan antarmuka
Camera.PictureCallback untuk menyimpan gambar yang
diterima dari kamera.
Sebelum mengatur method PictureCallback, tambahkan

sebuah method File getOutputMediaFile() yang berfungsi

untuk menentukan letak penyimpanan dan nama file yang
akan dibuat. Output dari method ini adalah sebuah file image
yang masih kosong.
Gambar 9.20 Fungsi getOutputMediaFile
Tambahkan code berikut pada fungsi onResume untuk

memanggil method PictureCallback()
Dimana mPicture merumapan variable dari objek
Camera.PictureCallback
Gambar 9.21 Fungsi onPictureTaken

Lalu tambahkan method setOnClickListener untuk menghandle
button click dan memanggil method takePicture()
Gambar 9.22 Fungsi Handle saat button shutter di click
Ketika button di click, aplikasi akan mengambil gambar (

takePicture() ) dan layar preview akan menampilkan gambar
yang diambil dan tidak menampilkan preview kamera. Untuk
menampilkan ulang tampilan preview camera, harus
menampikan ulang preview dari camera dengan memanggil
camera.startPreview()
Oleh karena itu switch case digunakan, aplikasi akan
menampilkan ulang preview camera Ketika previewState
bernilai BUSY, dan akan mengambil gambar Ketika
previewState bernilai PREVIEW.
Dimana nilai default dari previewState adalah “PREVIEW”.
Coba jalankan, dan click tombol untuk mengambil gambar.

Amati hasilnya
Untuk fungsi-fungsi camera lainnya dapat dilihat pada link

berikut :

• https://developer.android.com/training/camera
• https://developer.android.com/training/camera/cam
eradirect
• https://developer.android.com/guide/topics/media/c
amera
Tugas
• Mengerjakan Latihan diatas untuk menggunakan kamera pada
perangkat smartphone / emulator
• Ubah program diatas untuk kamera depan / kamera lainnya.

BAB 10
Menggunakan Sensor Android - Accelerator
A. Pendahuluan
Sebagian besar perangkat Android memiliki sensor bawaan yang
dapat digunakan untuk mengukur dan mendeteksi gerakan,
orientasi, dan berbagai kondisi lingkungan lainnya. Sensor ini
dapat memberikan data dengan akurasi dan presisi tinggi dan
dapat digunakan untuk memantau posisi atau pergerakan
perangkat serta memantau perubahan kondisi di lingkungan
sekitar perangkat.
Misalnya, jika membuat aplikasi game, maka memerlukan sensor
untuk mendeteksi gerakan dan gestur dari perangkat. Seperti tilt,
wobble, rotasi, swing, atau game yang menggunakan Virtual
Reality.
Demikian juga, jika perangkat mendukung sensor suhu, maka
dapat menggunakan sensor untuk mengetahui suhu dan
kelembaban perangkat.
B. Tipe Sensor
Secara garis besar, android mendukung 3 jenis tipe sensor, yaitu:
1. Sensor Gerak ( Motion Sensor)
Sensor dalam kategori ini mengukur akselerasi, akselerasi,
dan gaya rotasi perangkat berdasarkan sumbu x,y,z. Contoh:
Accelerometer, sensor gravitasi, giroskop, dan sensor vektor
rotasi.
2. Sensor Kondisi Lingkungan ( Environment Sensor)
Sensor dalam kategori ini mengukur parameter kondisi
lingkungan, seperti tekanan udara, suhu, pencahayaan, dan
kelembapan lingkungan di sekitar perangkat. Contoh:
barometer, fotometer, dan termometer.
3. Sensor Posisi (Position Sensor)
Sensor ini mengukur posisi fisik perangkat yang digunakan.
Contoh perangkat ini adalah Orientasi dan magnetometer.
C. Pengenalan Sensor
Kerangka kerja sensor Android memungkinkan untuk mengakses
berbagai jenis sensor. Beberapa sensor ini berbasis perangkat
keras dan beberapa berbasis perangkat lunak. Sensor berbasis

perangkat keras adalah komponen fisik yang dibangun ke dalam
perangkat handset atau tablet. Sensor mengambil data dengan
langsung mengukur sifat lingkungan tertentu, seperti percepatan,
kekuatan medan geomagnetik, atau perubahan sudut. Sensor
berbasis perangkat lunak bukanlah perangkat fisik, meskipun
mereka meniru sensor berbasis perangkat keras. Sensor berbasis
perangkat lunak mengambil data dari satu atau lebih sensor
berbasis perangkat keras dan terkadang disebut sensor virtual
atau sintetis. Sensor percepatan linier dan sensor gravitasi adalah
contoh sensor berbasis perangkat lunak. Tabel 1 merangkum
sensor yang didukung oleh platform Android.
Beberapa perangkat Android memiliki semua jenis sensor.
Misalnya, sebagian besar handset dan tablet memiliki
akselerometer dan magnetometer, tetapi hanya sedikit perangkat
yang memiliki barometer atau termometer. Selain itu, perangkat
dapat memiliki lebih dari satu sensor dari jenis tertentu. Misalnya,
perangkat mungkin memiliki dua sensor gravitasi, masing-masing
dengan jangkauan yang berbeda
Tabel 9.1 Contoh jenis-jenis Sensor
Sensor Jenis Deskripsi Penggunaan Umum
TYPE_ACCELERO Hardware Mengukur gaya Deteksi gerakan

METER akselerasi dalam (goyangan,
m/s2 yang diterapkan kemiringan, dll.).
di perangkat pada
ketiga sumbu fisik (x,
y, dan z), termasuk
gaya gravitasi.
TYPE_AMBIENT_T Hardware Mengukur suhu Memantau suhu
EMPERATURE ruangan sekitar dalam udara.
derajat Celcius (°C).
Lihat catatan di bawah.
TYPE_GRAVITY Software atau Mengukur gaya Deteksi gerakan
Hardware gravitasi dalam (goyangan,
m/s2 yang diterapkan kemiringan, dll.).
di perangkat pada

y, z).
TYPE_GYROSCOP Hardware Mengukur tingkat Deteksi rotasi
E rotasi perangkat dalam (berputar, berbalik,
rad/s di sekitar setiap dll.).
tiga sumbu fisik (x, y,
dan z).
TYPE_LIGHT Hardware Mengukur level cahaya Mengontrol
sekitar (pencahayaan) kecerahan layar.
dalam lx.
TYPE_LINEAR_AC Software atau Mengukur gaya Memantau
CELERATION Hardware akselerasi dalam akselerasi
m/s2 yang diterapkan sepanjang sumbu
di perangkat pada tunggal.
y, dan z), tidak
termasuk gaya
gravitasi.
TYPE_MAGNETIC_ Hardware Mengukur medan Membuat kompas.
FIELD geomagnetik sekitar
untuk ketiga sumbu
fisik (x, y, z) dalam μT.
TYPE_ORIENTATI Software Mengukur derajat Menentukan posisi
ON rotasi yang dibuat perangkat.
perangkat di sekitar
y, z). Pada API level 3,
Anda dapat
memperoleh matriks
kemiringan dan matriks
rotasi untuk perangkat
menggunakan sensor
gravitasi dan sensor
medan geomagnetik
bersama dengan
metode getRotationMa
trix().
TYPE_PRESSURE Hardware Mengukur tekanan Memantau

udara sekitar dalam perubahan tekanan
hPa atau mbar. udara.
TYPE_PROXIMITY Hardware Mengukur kedekatan Posisi telepon
objek dalam cm sesuai selama panggilan.
dengan layar tampilan
perangkat. Sensor ini
biasanya digunakan
untuk menentukan
apakah suatu handset
berada di telinga
seseorang.
TYPE_RELATIVE_ Hardware Mengukur kelembapan Memantau
HUMIDITY udara relatif dalam kelembapan relatif,
persen (%). mutlak dan titik
embun.
TYPE_ROTATION_ Software atau Mengukur orientasi Deteksi gerakan dan
VECTOR Hardware perangkat dengan deteksi rotasi.
memberikan tiga
elemen vektor rotasi
perangkat.
TYPE_TEMPERAT Hardware Mengukur suhu Memantau suhu.
URE perangkat dalam
derajat Celcius (°C).
Penerapan sensor ini
bervariasi antar
perangkat
D. Framework Sensor
Akses sensor sensor diatas dan untuk mendapatkan data mentah
hasil pengukuran diperlukan menggunakan Android sensor
framework. Framework sensor ini adalah bagian dari
android.hardware dan memiliki beberapa class dan tampilan
antarmuka seperti berikut
1. SensorManager
Class ini digunakan untuk membuat instance layanan sensor.
Class ini menyediakan berbagai metode untuk mengakses dan
mendaftar sensor, mendaftarkan dan membatalkan

pendaftaran pendengar peristiwa sensor, dan mendapatkan
informasi orientasi. Class ini juga menyediakan beberapa
konstanta sensor yang digunakan untuk melaporkan akurasi
sensor, mengatur kecepatan akuisisi data, dan mengkalibrasi
sensor.
2. Sensor
Class ini digunakan untuk membuat dan memanggil instansi
dari suatu sensor. Class ini menyediakan berbagai metode
yang dapat digunakan untuk menggunakan berbagai
kemampuan sensor
3. SensorEvent
Sistem menggunakan class ini untuk membuat objek yang
akan di panggil ketika terjadi sebuah event/peristiwa, yang
akan menyediakan informasi tentang event tersebut sensor.
Objek tersebut terdiri dari data pengukuran sensor, tipe sensor
yang digunakan, tingkat akurasi data, dan waktu terjadinya
event tersebut.
4. SensorEventListener
Method ini dapat digunakan interface ini untuk memanggil 2
method call back untuk menerima notifikasi dan data, ketika
data yang diambil berubah atau ketika akurasi sensor berubah.
void onAccuracyChanged(Sensor sensor, int accuracy)
Akan dipanggil ketika akurasi berubah
void onSensorChanged(SensorEvent event)
Akan dipanggil ketika data hasil pengukuran sensor
berubah
Dalam sebuah aplikasi standar, hanya perlu menggunakan

API untuk menggunakan sensor ini hanya dalam 2 pekerjaan
dasar :
1. Mengidentifikasi sensor dan kemampuan sensor
Mengidentifikasi sensor dan kemampuan sensor pada
saat runtime sangat berguna jika aplikasi yang dibuat
tergantung pada suatu sensor tertentu. Sebagai contoh,
diperlukan mengidentifikasi semua sensor yang dimiliki
sebuah perangkat dan mematikan semua aplikasi yang
menggunakan sensor tersebut, atau untuk menggunakan
kemampuan sensor tersebut agar menjadi optimal.

2. Memantau Aktifitas sensor
Memantau aktifitas sensor adalah cara untuk
mendapatkan data mentah dari hasil pengukuran sensor.
Event dari sensor akan aktif setiap sensor mendeteksi
perubahan pada parameter sensor yang sedang diukur.
Sensor akan memberikan 4 buah informasi dari hasil
pengukuran, yaitu : nama dari sensor yang mengukur,
waktu, akurasi, dan data mentah hasil pengukuran.
E. Menggunakan Sensor
1. Buat New Project, Beri nama Sensor_1, Gunakan minimum
API 21 keatas (21+) agar dapat menggunakan semua fitur
Gambar 10.1 Create New Project

2. Menambahkan Textview
Sebagai latihan, Untuk menampilkan hasil pengukuran dari
sensor, gunakan sebuah multiline textview. Tambahkan
sebuah textview dengan ukuran lebar.

Gambar 10.2 Tampilan Layout
3. Mengidentifikasi Jenis dan Kemampuan Sensor

Framework Sensor menyediakan beberapa method yang akan
memudahkan untuk mengetahui sensor apa saja yang ada
pada suatu perangkat. API sensor juga menyediakan method
untuk mengetahui setiap kemampuan dari sensor yang ada,
seperti range maksimum, resolusi, atau kebutuhan daya.
Untuk mengidentifikasi sensor, langkah pertama yang perlu
dilakukan adalah membuat sebuah instansi SensorManager
class dengan memanggil method getSystemService() dan
melempar argument SENSOR_SERVICE, seperti berikut

Selanjutnya, tambahkan code berikut untuk mengambil data
semua sensor yang ada dengan memanggil method
getSensorList() dan menggunakan konstanta TYPE_ALL
Semua sensor yang terdapat pada perangkat android, akan

disimpan pada variable List deviceSensors. Dan untuk
menampilkannya, tambahkan perulangan seperti berikut :
Sehingga menjadi seperti berikut
Gambar 10.3 Tampilan Kode onCreate

Dan jika di run akan menjadi seperti berikut
Gambar 10.4 List Sensor
Jika ingin menampilkan sensor untuk jenis tertentu saja, dapat

mengganti konstanta TYPE_ALL menjadi TYPE sensor
lainnya, seperti TYPE_GYROSCOPE,
TYPE_LINEAR_ACCELERATION dll, contoh :

Untuk mengecek apakah sensor jenis tertentu tersedia di
perangkat android dengan menggunakan method
getDefaultSensor() dan melemparkan attribut konstanta untuk
sensor secara spesifik. Jika sebuah perangkat memiliki lebih 1
sensor pada type tersebut, yang akan dipakai adalah yang
default. Dan jika sensor yang dimaksudkan tidak tersedia,
method tersebut akan bernilai null / kosong. Sebagai contoh,
kode berikut untuk mengecek apakah ada Accelerometer pada
sebuah perangkat.
Aplikasi akan menampilkan sebuah toast dengan keterangan

tersedia atau tidaknya sensor accelerometer.
Selain menampilkan list sensor yang ada di perangkat, dapat
menggunakan metode umum class Sensor untuk menentukan
kemampuan dan atribut masing-masing sensor. Hal ini
berguna jika ingin aplikasi yang di buat berperilaku berbeda,
tergantung sensor atau kemampuan sensor yang tersedia di
perangkat. Sebagai contoh, dapat menggunakan metode
getResolution() dan getMaximumRange() untuk mendapatkan
resolusi sensor dan rentang pengukuran maksimum. juga
dapat menggunakan metode getPower() untuk mendapatkan
persyaratan daya sensor.
Ada beberapa method lain yang cukup berguna, seperti
getVendor untuk menampilkan produsen sensor, getVersion
untuk menampilkan versi sensor, dan getMinDelay() yang
dapat digunakan untuk mengatur interval pengambilan data
oleh sensor.
4. Memantau Event Sensor

Untuk memantau data sensor mentah, perlu menerapkan dua
metode callback yang ditampilkan melalui antarmuka
SensorEventListener: onAccuracyChanged() dan
onSensorChanged(). Sistem Android memanggil metode ini
setiap kali hal berikut terjadi:

3. Akurasi sensor berubah
Dalam hal ini, sistem akan memanggil metode
onAccuracyChanged(), yang memberi referensi ke objek
Sensor yang berubah dan akurasi sensor yang baru. Akurasi
direpresentasikan oleh salah satu dari empat konstanta status:
SENSOR_STATUS_ACCURACY_LOW,
SENSOR_STATUS_ACCURACY_MEDIUM,
SENSOR_STATUS_ACCURACY_HIGH, atau
SENSOR_STATUS_UNRELIABLE.
4. Sensor mendeteksi nilai baru

Dalam hal ini, sistem akan memanggil metode
onSensorChanged(), yang menyediakan objek SensorEvent.
Objek SensorEvent berisi informasi tentang data sensor baru,
termasuk: akurasi data, sensor yang menghasilkan data,
stempel waktu untuk data yang dihasilkan, dan data baru yang
direkam sensor.
Untuk memantau event dari sensor perlu mengubah class

activity menjadi extends Activity dan implements
SensorEventListener{}
Ubah public class menjadi seperti berikut
Lalu tambahkan method onAccuracyChanged dan

onSensorChanged dengan cara mengklik lampu merah tanda
error seperti berikut
Gambar 10.5 Menambahkan method onAccuracyChanged

Pilih implement method

Gambar 10.6 Menambahkan method onAccuracyChanged
Maka method onSensorChanged dan onAccuracyChanged
akan terbuat secara otomatis pada bagian bawah activity.

Data dari sensor, akan dapat diambil/ditampilkan dengan
memanggil method SensorEvent.values[ ].
Dimana parameter dari values akan menampilkan data mentah
dari hasil pengukuran berdasarkan tabel yang dapat dilihat
pada
https://developer.android.com/guide/topics/sensors/sensors_m
otion.
5. Menggunakan Accelerometer
Untuk kali ini, akan digunakan Sensor Accelerometer, dimana :
Tabel 9.2 Sensor Accelerometer
Sensor Data kejadian sensor Keterangan Unit ukuran
TYPE_ACCELEROMETER event.values[0] Gaya akselerasi di m/s2

sepanjang sumbu x
(termasuk
gravitasi).
event.values[1] Gaya akselerasi di

sepanjang sumbu y
(termasuk
gravitasi).
event.values[2] Gaya akselerasi di

sepanjang sumbu z
(termasuk
gravitasi).
Dan untuk menggunakan nya, user perlu menambahkan code

berikut (Jika belum ada) :
Lalu panggil method callback onResume dan onPause untuk

memanggil method registerListener dan unregisterListener(),

dimana, setiap sensor yang digunakan, harus dipanggil dan di
register pada saat onResume, dan di unregister pada saat
onPause, ini dilakukan agar sensor tersebut dapat digunakan
oleh aplikasi lain ketika aplikasi yang dibuat sudah tidak
menggunakannya lagi.
Dan untuk menampilkan data hasil pengukuran, tambahkan

code berikut pada method onSensorChanged
Coba jalankan dan tampilkan hasilnya.

Maka aplikasi akan menampilkan data mentah yang
didapatkan dari accelerometer pada ketiga sumbu x,y,dan z.
Secara konseptual, Sensor accelerometer mengukur
akselerasi yang di terapkan kepada perangkat (Ad) dengan
mengukur gaya yang diterapkan kepada sensor tersebut (Fs)
menggunakan rumus berikut :
Namun, karena manusia tinggal di bumi, akan ada gaya

gravitasi yang selalu mempengaruhi nilai akselerasi, sehingga
rumus menjadi seperti berikut

Karena alasan ini, saat perangkat berada di atas meja (dan
tidak berakselerasi), akselerometer membaca kekuatan g =
9,81 m/s2. Demikian pula, saat perangkat jatuh bebas dan
karenanya dengan cepat berakselerasi ke tanah pada 9,81
m/s2, akselerometernya membaca kekuatan g = 0 m/s2.
Jadi untuk mengukur nilai real/asli dari percepatan yang
diterima oleh perangkat, kontribusi dari gaya gravitasi harus
dihilangkan. Hal ini dapat dilakukan dengan menambahkan
High-pass filter. Dan sebaliknya, Low-pass filter dapat
digunakan untuk mengisolasi nilai gaya dari gravitasi.
Berikut contoh source code untuk melakukan hal tersebut,

Tambahkan variable berikut
Lalu ubah isi dari method onSensorChanged menjadi seperti

berikut :

Gambar 10.7 onSensorChanged
Lalu coba jalankan dan tampilkan hasilnya.Aplikasi akan
menampikan nilai gravitasi setelah menggunakan low-pass
filter, dan akan menampilkan nilai percepatan setelah dihitung
menggunakan high-pass filter.
Gambar 10.8 Tampilan Akhir Aplikasi

6. Menggunakan Sensor Lain

Untuk menggunakan sensor lain, kurang lebih cara
penggunaannya sama dengan cara menggunakan sensor
accelerometer, data dapat diambil menggunakan
event.values[] pada method onSensorChanged, dan data
parameter secara lengkap dapat dilihat di link berikut :
1. Sensor Motion :
https://developer.android.com/guide/topics/sensors
/sensors_motion
2. Sensor Position :
/sensors_position
3. Sensor Environment :
/sensors_environment
7. Tugas
1. Kerjakan latihan diatas untuk menampilkan list
sensor, mengecek ketersediaan sensor, dan langkah-
langkah untuk menggunakan sensor Accelerometer
2. Ubah Apilkasi untuk Accelerometer tersebut
menggunakan jenis sensor lain selain sensor
Accelerometer yang tersedia pada perangkat yang
digunakan

BAB 11
Firebase
A. Pendahuluan
Firebase adalah platform yang dikembangkan oleh Google yang
digunakan untuk membuat aplikasi seluler dan web. Ini awalnya
dibuat oleh perusahaan independen pada tahun 2011, dan pada
tahun 2014 dibeli oleh Google. Dan kini firebase adalah platform
yang ditawarkan oleh Google untuk mempermudah proses
pengembangan aplikasi
B. Firebase Realtime Database
Firebase Realtime Database adalah database NoSQL berbasis

cloud yang tersedia secara real time dan dapat diakses di seluruh
platform dari Android, iOS, atau Web. Data dalam Firebase
Realtime Database disimpan dalam bentuk JSON tree yang selalu
tersinkronisasi secara realtime. Karena sifatnya yang realtime, jika
ada perubahan pada database, maka semua client yang
menggunakan Realtime Database ini akan tersinkronisasi secara
otomatis. Dan juga tipe databasenya adalah tipe NoSQL, sangat
cocok ketika ingin menyimpan data key-value di dalam aplikasi.
Gambar 11.1 Contoh Tampilan Fiebase Realtime Database

C. Mengembangkan aplikasi CRUD menggunakan Firebase
Realtime Database
Langkah – Langkah umum untuk mengembangkan aplikasi
firebase adalah sebagai berikut :
1. Membuat Project baru untuk mengembangkan aplikasi
CRUD Firebase Realtime Database
2. Melakukan sinkronisasi firebase realtime database dengan
aplikasi android studio
3. Membuat class model untuk data yang akan dibuat
4. Membuat tampilan untuk melakukan proses CRUD
5. Menambahkan Fitur Create, Read, Update, dan Delete
data pada Firebase
Aplikasi yang akan dikembangkan adalah sebuah aplikasi CRUD

menggunakan Firebase Realtime Database yang akan
menampilkan data Biodata sebagai data yang diolah. Yang
masing-masing data dari firebase akan ditampilkan dalam sebuah
komponen listview. Dan jika di klik akan menampilkan opsi untuk
mengupdate atau mendelete data.
Gambar 11.2 Contoh Tampilan Aplikasi

1. Buat New Project, Beri nama FirebaseRealtime_1,
Gunakan minimum API 21 keatas (21+) agar dapat
menggunakan semua fitur

2. Melakukan sinkronisasi firebase realtime database dengan
aplikasi android studio
Pada langkah berikutnya login/masuk pada Firebase dengan
menggunakan Alamat Gmail pada link berikut
ini https://firebase.google.com/?hl=id
Gambar 11.3 Halaman Awal Firebase Console

Lalu klik mulai untuk masuk ke halaman console firebase. Dan
klik add project untuk membuat project baru.
Beri nama project yang dibuat pada kolom yang

disediakan.Lalu klik Continue
Gambar 11.4 Setting Google Console Firebase

Atur setting untuk Google Analytics untuk
mengaktifkan/menonaktifkan Google Analytics pada project

yang dibuat (Opsional/bebas). Lalu klik continue/create project.
Lalu akan diarahkan ke dalam console pengaturan dari project
yang telah dibuat, klik simbol android di bagian tengah layar
untuk memulai menambahkan Firebase ke dalam project
android studio.
Gambar 11.5 Tampilan Firebase Console (2)

Isikan android package name dengan ide dari project android
studio yang telah dibuat sebelumnya. (ID dapat dilihat dari
project android studio di file build.gradle(app)
Gambar 11.6 Setting Project Firebase

Di pilihan diatas ada kolom untuk mengisinkan Signing
certificate SHA-1(optional) yang mana akan diperlukan jika
aplikasi yang dibuat akan di upload ke App store seperti play
store untuk pengamanan. Dan untuk project ini karena belum
dibutuhkan, biarkan dalam keadaan kosong.
Kemudian klik tombol register app.
Langkah selanjutnya yaitu download config file, yang perlu
ditambahkan(copy-paste) ke dalam folder project android
studio yang telah dibuat. Untuk menambahkan file config, ubah
ke dalam project view pada panel project structure
Gambar 11.7 Ganti Tampilan Android Studio Struktur FIle

Kemudian copy kan file google-services.json yang telah
didownload. Lalu kembali pada layar console firebase, dan klik
next.
Console Firebase akan menunjukkan cara untuk
menambahkan code untuk menggunakan file google-services
yang baru ditambahkan. Copy classpath
'com.google.gms:google-services:4.3.5' ke dalam file
build.gradle(project) dibagian dependencies.
Dan tambahkan
apply plugin: 'com.google.gms.google-services'
Dan
implementation platform('com.google.firebase:firebase-
bom:27.1.0')

ke dalam file build.gradle(app), sehingga menjadi seperti
berikut
Gambar 11.8 Tampilan build.gradle(app),

Kemudian klik sync now di bar pada bagian atas layar
Setelah setting build.gradle selesai, kembali ke layar console

firebase, pilih menu Realtime Database Dan klik tombol create
database untuk memulai membuat database realtime
Gambar 11.9 Create Realtime Database

Pilih location Singapore kemudaian Rubah pilihan security
menjadi test mode agar database bebas untuk dirubah.Lalu
klik enable.

Gambar 11.10 Setting Security Rules
Untuk menambahkan database realtime yang sudah dibuat

pada project, buka tools -> firebase pada android studio.
Pilih realtime Database, dan klik Get Started with Realtime

Database. Klik tombol connect to Firebase, kemudian pilih
project pada console firebase yang telah dibuat sebelumnya.
Gambar 11.11 Setting Firebase pada android studio
Kemudian Klik add the Realtime Database SDK to your app

pada android studio. Dan klik pilihan Accept Changes.

Gambar 11.12 Setting Firebase pada Android Studio
Tunggu proses sinkronisasi selesai. Dan Realtime Database
siap untuk digunakan.
D. Menambahkan Class Model Biodata
Untuk mengatur data biodata, dibutuhkan sebuah class

Biodata yang digunakan untuk memanage data dari Biodata
dari firebase ke dalam android. Atau sebaliknya. Buat sebuah
java class baru, beri nama biodata.
Database Biodata, nantinya akan memiliki 4 buah data, yaitu,

id, nama, umur, dan jenis kelamin. Pada file Biodata.java yang
baru dibuat, tambahkan variable string sesuai dengan data
tersebut.
Dan tambahkan 2 buah method konstuktor untuk kelas

Biodata. Method konstruktor akan dipanggil ketika object

biodata dibuat/digunakan. Method pertama merupakan method
konstruktor kosong, dan method yang kedua akan dipanggil
jika objek biodata dipanggil dengan isian parameter berupa
id,nama,umur, dan jenis kelamin.
Kemudian tambahkan method get untuk semua parameter.
Sehingga tampilan dari class biodata akan menjadi seperti
berikut
Gambar 11.13 Class Biodata
E. Membuat Tampilan Untuk Melakukan Proses CRUD

Untuk tampilan yang digunakan untuk proses CRUD, terbagi
menjadi 2 activity, dan 1 tampilan untuk listView. Activity
pertama untuk menambahkan data (Create) dan menampilkan
data dari database (Read). Dan Activity yang kedua untuk
proses Update dan Delete.
Pada layout activity_main.xml tambahkan 2 EditText, 1
Spinner, 1 Button, dan 1 ListView. Sehingga tampilan menjadi
seperti berikut :

Gambar 11. 14 Contoh Tampilan Listview
Array jeniskelamin adalah sebuah string-array yang

ditambahkan pada file strings.xml
Tambahkan sebuah activity baru, yang nantinya digunakan

untuk proses update dan delete. Pada activity tersebut,
tambahkan 2 EditText, 1 Spinner, dan 2 Button untuk update
dan delete.

Gambar 11.15 Layout Activity 2
Untuk listview, buatlah sebuah layout baru, berinama
layoutlistview. Dan untuk komponennya, tambahkan 3 buah
textview yang nantinya digunakan untuk menampilkan
nama,umur, dan jenis kelamin.
Gambar 11.16 Layout Activity 2

Gambar 11.17 Listview
Kemudian tambahkan sebuah java class untuk mengatur
listView,

Gambar 11.18 Setting Java Class
Buat sebuah method constructor pada class listview_biodata
dengan code seperti berikut, dimana method ini dibuat untuk
menampilkan listview_biodata dari layout_listview.xml yang
telah dibuat sebelumnya.
Masih di class listview_biodata, Tambahkan method getView,

yang nantinya akan dipanggil setiap data biodata dari firebase
yang ditampilkan dalam 3 buah textView, yaitu nama, umur,
dan jenis kelamin.
Sehingga menjadi seperti berikut

F. Menambahkan Fitur Create (Menambahkan data ke
firebase)
Untuk menambahkan data ke firebase (Create) diperlukan
sebuah object DatabaseReference yang nantinya digunakan
sebagai referensi data dari firebase. Tambahkan code berikut
untuk menambahkan editText, Spinner, dan
DatabaseReference pada file MainActivity.java

databaseBiodata =
FirebaseDatabase.getInstance().getReference("biodata");
Pada code diatas, databaseReference databaseBiodata,
diisikan isi dari database firebase pada referensi “biodata” atau
jika menggunakan database sql, dikenal dengan nama tabel
“biodata” . Contoh data yang diambil dari referensi “biodata”
adalah sebagai berikut:
Gambar 11.19 Contoh Data dari Firebase

Maka seluruh data yang berada didalam referensi biodata
tersebut akan diambil dan dimasukan ke object
databaseBiodata yang telah dibuat sebelumnya, termasuk id,
Nama, Umur, dan Jenis Kelamin dari semua data yang ada.
Kemudian, database akan ditambahkan ketika buttonAddBio di
klik, untuk itu, buat sebuah method untuk menghandle onClick
dengan nama addBiodata(View view). Dan tambahkan ke
attribut android:onClick
Kemudian, pada method tersebut, tambahkan code untuk

menambahkan data dari editText dan spinner ke dalam
database Firebase seperti berikut. Ambil data dari editText dan
Spinner ke dalam Variable String, kemudian lakukan
pengecekan nilai kosong (isEmpty()) agar aplikasi tidak force
close ketika input masih kosong.

Nama, Umur dan Jenis Kelamin diambil dari input yang
dimasukan user ke editText dan Spinner, dan untuk id, dibuat
secara otomatis. Id nantinya digunakan sebagai penanda dari
setiap data, yang setiap id akan berbeda antara 1 dengan
yang lainnya (unik). Untuk membuat id unik tersebut,
tambahkan code berikut,yang merupakan fitur yang telah
disediakan untuk membuat id atau key.
String id = databaseBiodata.push().getKey();
Dan tambahkan code berikut didalam block if untuk melakukan

penambahan data ke dalam database Firebase:
Pada bagian else tambahkan toast untuk menampilkan jika

input masih kosong:

Coba jalankan, dan coba input data pada editText dan spinner
lalu klik tombol ADD. Cek data yang barusan ditambahkan
pada web console firebase. Pastikan data yang telah
ditambahkan telah tersedia.
Gambar 11.20 Contoh Tampilan pada aplikasi

G. Menambahkan Fitur Read (Menampilkan data dari
firebase)
Untuk menampilkan data dari firebase, nantinya data akan
ditampilkan pada ListView yang telah dibuat sebelumnya.
Langkah pertama yang perlu dilakukan adalah membuat objek
instansi dari listView dan sebuah variable List untuk
menyimpan data Biodata sementara :
Dan pada method onCreate tambahkan :

Kemudian panggil method callback onStart, dimana nantinya
data dari firebase akan dipanggil setiap method callback
onStart dipanggil. Tambahkan code berikut :
Dimana method databaseBiodata.addValueEventListener

adalah method yang digunakan untuk mengambil data dari
firebase.
Kemudian coba jalankan aplikasi dan lihat hasilnya. Pastikan
data yang tampil di listview sudah sama dengan yang ada
pada console Firebase.

Gambar 11.21 Tampilan Add pada aplikasi
H. Menambahkan Fitur Update dan Delete
Fitur Update dan Delete akan di manage pada activty yang
kedua yaitu mainactivity2, Oleh karena itu dari
MainActivity.java akan mengirimkan data (intent) berupa id dari
data yang di klik pada listView menuju MainActivity2.
Pada method onCreate, di MainActivity.java, tambahkan code
sebagai berikut untuk berpindah activity (intent) ketika listView
di klik :
Kemudian pada MainActivity2.java, tambahkan code

untuk mengambil id dari intent yang dikirimkan dari

MainActivity.java, id tersebut akan digunakan sebagai
referensi untuk pemanggilan data dari firebase.
Dimana
Hanya akan memanggil data dari firebase dengan id yang

sama dengan id yang dikirimkan dari MainActivity.java
sebelumnya.
Kemudian, panggil method callback onStart yang isinya untuk
menampilkan nama, umur, dan jenis kelamin dari firebase ke
dalam editText dan spinner.

Untuk proses update dan delete, nantinya data akan di update
ketika button update di klik, dan akan dihapus ketika button
delete di klik, untuk itu tambahkan method button handler
untuk keduanya :
Dan kemudian tambahkan pada attribut android:onClick pada

kedua button/
Untuk proses update, mirip dengan proses penambahan data,

tambahkan code seperti berikut pada method
buttonudateBiodata().

Dan untuk proses Delete, panggil method .removeValue untuk
menghapus data sesuai id biodata. Tambahkan code seperti
berikut pada method buttondeleteBiodata().
Pada proses update dan delete, terdapat perintah finish() yaitu

perintah yang dipanggil ketika proses update dan delete
sukses, MainActivity2.java akan di tutup, dan akan kembali ke
activity utama yaitu MainActivity.java.
Coba jalankan dan pastikan aplikasi telah berhasil untuk
proses update dan delete data.

Gambar 11.22 Tampilan Apilaksi Update
Gambar 11.23 Tampilan Aplikasi Delete

Gambar 11.24 Tampilan Full Code Aplikasi Firebase
Tugas
• Mengerjakan Latihan diatas untuk menggunakan Database
SQLite
• Buat program sederhan menggunakan database SQLite
yang berbeda dengan program diatas.

DAFTAR PUSTAKA
Harton, John. 2018. Android Programming for Beginners_ Build in-

depth, full-featured Android 9 Pie apps starting from zero
programming experience, 2nd Edition. Packt Publishing.
Schildt, Herbert. 2017. Java: The Complete Reference.

Comprehensive Coverage of the Java Language. 10th Edition.
McGraw-Hill Education.
Späth, Peter; Friesen, Jeff. 2020. Learn Java for Android

Development: Migrating Java Se Programming Skills to Mobile
Development. 4th Edition. Apress.
Android Developers. 2022. Android Mobile App Developer Tools –

Android Developers. [online] Available at:
<https://developer.android.com/> [Accessed 2022].
Rheny, Sylvia. 2022. Layout Adalah: Pengertian, 5 Elemen Desain

Layout, Manfaat, Dan Prinsip Pembuatannya [online] Available at: <
https://www.ekrut.com/media/layout-adalah. /> [Accessed 2022].
Android Developers. 2022. Mengenal Android Studio, [online]

Available at: <https://developer.android.com/> [Accessed 2022].
Android Developers. 2022. Tata Letak Relatif, [online] Available at:

<https://developer.android.com/> [Accessed 2022].
Android Developers. 2022. Membuat UI Responsif dengan Constrain

Layout [online] Available at: <https://developer.android.com/>
[Accessed 2022].
Rustan, Surianto. (2009). Layout Dasar Dan Penerapannya. Jakarta:

Gramedia.

GLOSARIUM
1 Activity : komponen yang menampilkan dan mengatur

halaman aplikasi sebagai tempat interaksi antara
pengguna dengan aplikasi Android
2 Accelerometer : sebuah perangkat yang mengukur percepatan

yang tepat
3 Class : Merupakan prototype yang mendefinisikan atribut

dan methode secara umum
4 Callback : Set inti yang disediakan class Activity untuk

menavigasi transisi diantara tahap siklus proses
aktivitas
5 Console : Prompt utama pada sebuah sistem komputer atau

sistem operasi yang menggunakan perintah
berbasis teks
6 Component : Menampilkan hierarki komponen dalam tata letak

tree
7 Command line : Program yang memungkinkan pengguna

interface mengetik perintah teks yang memerintahkan
komputer untuk melakukan tugas tertentu.
8 Debug : Menjalankan sebuah program dengan interaktif
9 Explicit intent : berfungsi untuk mengaktifkan activity yang dibuat

oleh user dalam satu aplikasi yang sama
10 Fragmen : adalah bagian dari antarmuka pengguna dalam

sebuah FragmentActivity
11 Firebase : Perangkat database dari Google yang dapat

digunakan untuk membantu para developer
mengembangkan aplikasi mereka
12 Intent : sebuah jembatan penghubung yang digunakan

untuk perpindahan halaman antar activity dalam

aplikasi
13 Implicit intent : untuk memanggil fungsi activity yang sudah

tersedia pada fungsi internal android seperti
Kamera, Dial Number, Open Browser dan
lainnya.
14 Internal device : Perangkat bawaan yang telah disediakan oleh

smartphone android seperti kamera, call, dialpad,
dll
15 Method : Kumpulan pernyataan yang dikelompokkan

bersama untuk melakukan operasi
16 Manifest :Xml yang berisi informasi mengenai aplikasi

Seperti nama package, level SDK yang di
gunakan, berserta icon dan nama yang di berikan
untuk aplikasi.
17 Object : Hasil instansiasi dari sebuah Class, memiliki

atribut dan behaviour
18 Palette : Berbagai tampilan dan kelompok tampilan yang

dapat ditarik ke dalam tata letak.
19 Statement : Unit sintaks pada bahasa

pemrograman yang menyatakan aksi atau tugas
untuk dilakukan
20 Toast : Mekanisme di Andorid untuk menampilkan popup

kecil sebagai sebuah feedback dan akan
menghilang setelah beberapa waktu

INDEKS
Accelerometer, 51, 61, 64, 69 Constraint Layout, 61

Akselerometer, 52, 66 CONSTRAINT LAYOUT, 62
Amazon App Store, 1 CPU, 2, 5
Android Application Package, 5 Create Read Update Delete,
11
APK, 6
CRUD, 11, 71, 72, 81
Android Application
Proggraming Interface, 3 Dalvik Executable, 2
API, 3, 4, 5, 6, 7, 35, 62, 20, DEX, 2, 5, 6
21, 22, 23, 24, 25, 26, 27, 30,
Dalvik Virtual Machine, 2
34, 53, 56, 58, 72
DVM, 2, 3, 5, 6
Android Studio, 6, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26, Deprecated, 32
28, 30, 31, 33, 34, 36, 37, 48,
57, 62, 72, 12, 13, 20, 26, 27, Design, 53
28, 29, 75, 79 Developer Options, 30
Android Virtual Device, 17 Drawable, 41
AVD, 17 Environment Sensor, 51
Androidmanifest.Xml, 28, 37, Firebase, 70, 71, 72, 73, 74,
38, 18, 26, 29, 34, 35 75, 78, 79, 87, 89, 90, 92, 98
Boolean, 70, 13, 36 FRAGMENT, 5
Callback, 44, 45, 46, 49, 6, 9, Fragmen, 5, 6, 7, 8, 9, 10, 11,
10, 11, 12, 37, 38, 61, 65, 91, 15
94
Framework, 55, 58
Camera, 32, 34, 37, 38, 39, 42,
43, 44, 45, 47, 48 Google App Engine, 33
Kamera, 69, 32, 33, 34, 35, 37, Google Play

38, 40, 43, 44, 47, 49, 50
Google Play Store, 1, 20, 21,
Compile, 2 29
Componen Tree, 54 Googlemap, 69

GPU, 2, 5 Object Oriented,, 4
Gradle, 36, 42, 43, 26, 27, 30, OOP, 4, 7, 9, 10, 11, 12, 13,
74, 75, 76 14, 15
IDE, 7 Open Source, 1
Integrated Development Opsi Developer, 30, 31
Environtment, 7
Orientasi, 54, 61, 43, 44, 51,
Intent, 69, 70, 71, 72, 73, 74, 54, 55
75, 77, 78, 79, 80, 82
Override, 49, 50, 12
Internal Device, 69, 74
Package, 8, 27, 35
J2SE, 7
PERMISSION, 36
Java Development Kit, 6
Prototipe, 1
JDK, 6, 7
Realtime Database, 70, 71, 72,
Java EE, 7 76, 77, 78, 79
Java SE, 7 RELATIF LAYOUT, 62
Java Virtual Machine, 7 Runtime, 7, 8, 56
JVM, 7 SDK, 6, 18, 22, 23, 24, 27, 35,
20, 22, 78
JSON Tree, 70
Software Development Kit, 6,
Library, 8
18
Library, 5, 7, 8, 33, 43, 39
User Permission, 33, 37
Linear Layout, 61, 63, 64
Values, 42
Linux, 2, 5, 8
Virtual Device, 29
Magnetometer, 52
Mipmap, 41
Motion Sensor, 51
Multi-Platform, 8
Multi-Purpose, 8
Object Oriented Programming,
4

BIODATA PENULIS
Putri Elfa Masùdia, ST., M.Cs merupakan lulusan

lulusan Magister Computer Science Universitas
Gadjah Mada Yogyakarta. Saat ini berprofesi
sebagai dosen tetap di program studi Teknik
Telekomunikasi di Politeknik Negeri Malang. Bidang
keahlian sesuai dengan matakuliah yang diampu
yaitu Dasar Pemrograman Komputer dan
Pemrograman Aplikasi Mobile. Telah mendapatkan
sertifikasi android yang diadakan oleh inixindo, Minat penelitian di
bidang IoT, Aplikasi dan kecerdasan buatan, Telah mempunyai 4 HKI
di Foto
bidang aplikasi
Penulis 1 dan IoT, Email : putri.elfa@polinema.ac.id
Adzikirani, S.S.T., M.Tr.T. merupakan lulusan

magister terapan teknik elektro Politeknik Negeri
Malang. Saat ini berprofesi sebagai dosen di
program studi Teknik Telekomunikasi di Politeknik
Negeri Malang. Bidang keahlian meliputi
pemrograman dan aplikasi mobile. Saat ini
mengampu mata kuliah pemrograman aplikasi
mobile dan antena. Email:
adzikirani@polinema.ac.id
Dimas Rossiawan Hendra Putra menerima gelar

M.Tr.T. di bidang teknik elektronika dari Politeknik
Negeri Malang, Indonesia. Saat ini menjadi dosen di
bidang Jaringan Telekomunikasi Digital, Jurusan
Teknik Elektro di Politeknik Negeri Malang. Selama
ini telah mengajar mata kuliah yang berhubungan
dengan, Jaringan Komputer, Keamanan Jaringan
Komputer, Kecerdasan Buatan, Pemrograman
Aplikasi Mobile, Pemrograman dan rekayasa Web, dasar sistem
telekomunikasi, dan Sistem Komunikasi Satelit. Minat penelitian
meliputi pemrosesan gambar, pemrosesan simultan, Kecerdasan
Buatan, dan visi komputer. Email: dimas.rossi@polinema.ac.id.

26 Pemrograman Aplikasi Mobile - Putri - Telkom - Fix - Putri Elfa Mas'Udia

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

26 Pemrograman Aplikasi Mobile - Putri - Telkom - Fix - Putri Elfa Mas'Udia

Diunggah oleh

Hak Cipta:

Format Tersedia

PEMROGRAMAN APLIKASI MOBILE

Putri Elfa Mas`udia, S.T., M.Cs

PEMROGRAMAN APLIKASI MOBILE i

Desain & Tata Letak:

Undang-Undang RI Nomor 19 Tahun 2002

ii PEMROGRAMAN APLIKASI MOBILE

Kami ucapkan juga terimakasih kepada pihak-pihak yang telah

Penulisan buku ajar kami yang berjudul “Pemrograman

Malang, 1 Juli 2022

PEMROGRAMAN APLIKASI MOBILE iii

Politeknik Negeri Malang

JURUSAN TEKNIK ELEKTRO

PROGRAM STUDI : TEKNIK TELEKOMUNIKASI

RENCANA PEMBELAJARAN SEMESTER (RPS)

iv PEMROGRAMAN APLIKASI MOBILE

Mahasiswa mampu memahami konsep dasar Teknologi Mobile

PEMROGRAMAN APLIKASI MOBILE v

(1) (2) (3) (4) (5) (6) (7) (8) (9)

1 1. Mengenal 1. Konsep 1. Ceramah 1x4x45’ 1. Mendengarka 1. Tanya jawab 1. Mampu 5%

vi PEMROGRAMAN APLIKASI MOBILE

PEMROGRAMAN APLIKASI MOBILE vii

viii PEMROGRAMAN APLIKASI MOBILE

PEMROGRAMAN APLIKASI MOBILE ix

x PEMROGRAMAN APLIKASI MOBILE

12 1. Mahasiswa 1. Akses 1. Kelas 1x4x45 1. Mendengarka 1. Tanya jawab 1. Ketepatan 15%

PEMROGRAMAN APLIKASI MOBILE xi

xii PEMROGRAMAN APLIKASI MOBILE

KATA PENGANTAR ........................................................................................... iii

RENCANA PEMBELAJARAN SEMESTER (RPS) .......................................... iv

DAFTAR ISI ...................................................................................................... xiii

BAB 1 PENGENALAN JAVA DAN PEMROGRAMAN APLIKASI MOBILE1

Kenapa Android dan Java Dibutuhkan ........................................................... 1

A. Bagaimana Java dan Android Bekerja Sama ....................................... 2

B. API ANDROID ......................................................................................... 3

C. Java adalah Object-Oriented.................................................................. 3

D. Apakah Android itu Sebenarnya? .......................................................... 5

E. Android Studio ......................................................................................... 5

F. Seputar Tentang Bahasa Pemrograman Java ...................................... 6

BAB 2 INSTALASI ANDROID STUDIO ...................................................... 14

B. Instalasi Android Studio ......................................................................... 14

C. Membuat Project Sederhana di Android Studio ................................... 21

BAB 3 STRUKTUR PROJECT ANDROID .................................................. 28

A. Struktur Project ...................................................................................... 28

B. Cara Membuat Project .......................................................................... 28

C. Jendela Utama Android Studio ............................................................ 30

BAB 4 ACTIVITY .......................................................................................... 39

B. Activity Life Cycle (Daur Hidup Activity) .............................................. 39

D. Cara Membuat Activity Sederhana ...................................................... 47

PEMROGRAMAN APLIKASI MOBILE xiii

B. LINEAR LAYOUT .................................................................................. 56

C. RELATIF LAYOUT ................................................................................ 57

D. CONSTRAINT LAYOUT ....................................................................... 57

E. Contoh Membuat Layout Menggunakan Linear Layout ...................... 57

F. Contoh Membuat Layout Menggunakan Relatif Layout ..................... 60

BAB 6 INTERAKSI ANTAR ACTIVITY (INTENT) ....................................... 63

B. Cara Membuat Explicit Intent................................................................ 64

C. Cara Membuat Implicit Intent ................................................................ 67

D. Cara Mengirim Data Antar Activity ....................................................... 68

E. Studi kasus Radio Button ...................................................................... 73

F. Studi Kasus List View ............................................................................80

A. URAIAN MATERI FRAGMEN .............................................................. 83

B. MEMBUAT FRAGMEN ......................................................................... 86

C. Mengelola Daur Hidup Fragmen ..........................................................88