Modul Pemrograman Mobile BAB IV 2021

MODUL PEMROGRAMAN MOBILE DENGAN ANDROID STUDIO – ANDI BASO KASWAR
BAB IV
ACTIVITY
Activity (aktivitas) menyatakan layar tunggal di aplikasi Anda dengan antarmuka yang bisa
digunakan pengguna untuk berinteraksi. Misalnya, pada smartphone anda terdapat sebuah aplikasi
email. Aplikasi email tersebut mungkin memiliki beberapa aktivitas diantaranya sebuah aktivitas
yang menampilkan daftar email baru, aktivitas untuk menulis email, dan aktivitas lainnya lagi untuk
membaca pesan satu per satu. Pada dasarnya, aplikasi Anda adalah koleksi aktivitas yang dibuat
sendiri atau yang digunakan kembali dari aplikasi lain.
Meskipun aktivitas di aplikasi Anda bekerja sama satu sama lain untuk membentuk user
experience yang kohesif, setiap aktivitas tidak tergantung pada yang lain. Ini memungkinkan aplikasi
Anda untuk memulai aktivitas di aplikasi lain, dan itu memungkinkan aplikasi lain untuk memulai
aktivitas di aplikasi Anda (jika aplikasi Anda memungkinkan ini). Misalnya, aplikasi olah pesan
dapat memulai aktivitas dalam aplikasi kamera untuk mengambil gambar, kemudian memulai
aktivitas dalam aplikasi email untuk memungkinkan pengguna berbagi gambar dalam email.
Gambar 4.1. Ilustrasi aktivitas pada suatu aplikasi
102
Biasanya, satu Aktivitas dalam aplikasi ditentukan sebagai aktivitas "utama", misalnya
MainActivity. Pengguna akan melihat aktivitas utama ketika mereka meluncurkan aplikasi untuk
pertama kalinya. Setiap aktivitas dapat memulai aktivitas lain untuk melakukan aksi yang berbeda.
Setiap kali aktivitas baru dimulai, aktivitas sebelumnya dihentikan, tetapi sistem
mempertahankan aktivitas dalam tumpukan ("back stack"). Ketika pengguna selesai dengan aktivitas
saat ini dan menekan tombol Kembali, aktivitas tersebut muncul dari tumpukan dan dihancurkan,
dan aktivitas sebelumnya dilanjutkan.
Ketika suatu aktivitas dihentikan karena aktivitas baru dimulai, aktivitas pertama akan
diberitahu melalui metode panggilan balik siklus aktivitas. Siklus hidup aktivitas adalah sekumpulan
status yang dapat diikuti oleh Aktivitas: saat aktivitas pertama kali dibuat, saat dihentikan atau
dilanjutkan, dan saat sistem menghancurkannya.
A. Membuat dan memulai aktivitas

Untuk menerapkan Aktivitas di aplikasi Anda, lakukan hal berikut:
• Buat Java class Activity.
• Implementasikan UI dasar untuk Aktivitas dalam file layout XML.
• Deklarasikan Aktivitas baru di file AndroidManifest.xml.
Saat Anda membuat proyek baru untuk aplikasi Anda, atau menambahkan Aktivitas baru ke aplikasi
Anda dengan memilih File> New> Activity, template secara otomatis akan melakukan langkah-
langkah yang tercantum di atas.
Praktikum 4.1. Membuat Proyek Dua Aktivitas

# Membuat project dua aktivitas
1. Buatlah sebuah project baru dengan ketentuan berikut:
Nama Aplikasi :“Namapanggilanmu”DuaAktivitas

Language :Java
Minimum API level :API 16: Android 4.1 (Jelly Bean)
Tempalte :Empty Activity
2. Buka res/layout/activity_main.xml.
3. Konversi layout ke relative layout dan tambahkan padding 15dp
pada semua sisi layout.
103
# Membuat layout untuk aktivitas utama
4. Pada Layout Editor, klik tab Design di bagian bawah layar.

5. Hapus TextView yang menampilkan text "Hello World"
# Membuat layout untuk aktivitas utama

6. Tambahkan Tombol ke layout dalam posisi apa pun.
7. Beralih ke Editor XML (klik tab Teks), pilih Button dan ubah
atribut:
No Nama atribut Nilai

1 id "@+id/tombol_utama"
2 layout_width wrap_content
3 layout_height wrap_content
4 layout_alignParentRight "true"
5 layout_alignParentBottom "true"
6 layout_alignParentEnd "true"
7 text "Kirim"
8 onClick "luncurkanAktivitaskedua "
Atribut di atas mungkin akan menampilkan error bahwa "Method

launchSecondActivity is missing in MainActivity". Harap abaikan
kesalahan ini untuk saat ini. Ini akan ditangani dalam tugas
selanjutnya.
8. Tempatkan kursor pada kata "Kirim".

9. Tekan Alt-Enter (Option-Enter pada Mac) dan pilih Extract
string resources.
10. Tetapkan Nama sumber daya ke tombol_utama dan klik OK.
Ini menciptakan sumber daya string dalam file
values/res/string.xml, dan string dalam kode Anda diganti
dengan referensi ke sumber daya string itu.
11. Pilih Code > Reformat Code untuk memformat kode XML, jika
perlu.
12. Preview layout aktivitas utama menggunakan Editor Layout.
Layout akan terlihat seperti ini:
104
13. Pada Editor XML, tempatkan kursor pada kata

"luncurkanAktivitaskedua".
14. Tekan Alt-Enter (Option-Enter pada Mac) dan pilih Buat
'luncurkanAktivitaskedua (View)' di 'MainActivity’.
File MainActivity.java terbuka, dan Android Studio menghasilkan
metode kerangka untuk penangan onClick.
15. Di dalam luncurkanAktivitaskedua, tambahkan pernyataan log
yang bertuliskan "Tombol ditekan!"
Log.d(LOG_TAG, "Tombol ditekan!");
16. LOG_TAG akan ditampilkan sebagai error. Definisi untuk

variabel tersebut akan ditambahkan pada langkah selanjutnya.
17. Tempatkan kursor pada kata "Log" dan tekan Alt-Enter (Option-
Enter pada Mac). Android Studio menambahkan pernyataan impor
untuk android.util.Log.
18. Di bagian atas kelas MainActivity, tambahkan konstanta untuk
variabel LOG_TAG:
private static final String LOG_TAG =
105
MainActivity.class.getSimpleName();
Konstanta ini menggunakan nama kelas itu sendiri sebagai tag.
Jalankan aplikasi Anda. Ketika Anda mengklik tombol "Kirim" Anda

akan melihat pesan "Tombol Ditekan!" di Monitor Android (logcat).
Jika terdapat terlalu banyak output di monitor, ketik MainActivity
ke dalam kotak pencarian dan log hanya akan menampilkan garis yang
cocok dengan tag tersebut.
Setiap aktivitas baru yang Anda tambahkan ke proyek Anda memiliki layout XML dan file
Java sendiri, terpisah dari aktivitas utama. Mereka juga memiliki elemen <activity> mereka sendiri
dalam Android manifest. Seperti halnya aktivitas utama, aktivitas baru yang Anda buat di Android
Studio juga diperluas (extend) dari AppCompatActivity class.
Semua aktivitas di aplikasi Anda hanya terhubung secara fleksibel satu sama lain. Namun,
Anda dapat menetapkan suatu aktivitas sebagai induk dari aktivitas lain dalam file
AndroidManifest.xml. Hubungan parent-child ini memungkinkan Android untuk menambahkan
petunjuk navigasi seperti panah yang menghadap ke kiri di bilah judul untuk setiap aktivitas.
Aktivitas berkomunikasi satu sama lain (baik di aplikasi yang sama dan di aplikasi yang
berbeda) dengan Intent. Ada dua jenis Intent, eksplisit dan implisit. Intent eksplisit adalah tujuan di
mana target Intent itu diketahui, yaitu, Anda sudah tahu nama kelas yang sepenuhnya memenuhi
syarat untuk aktivitas spesifik itu. Intent implisit adalah Intent di mana Anda tidak memiliki nama
komponen target, tetapi memiliki tindakan umum untuk dilakukan.
Dalam praktikum ini Anda akan menambahkan aktivitas kedua ke aplikasi, dengan
layoutnya sendiri. Anda akan memodifikasi Android manifest untuk menetapkan aktivitas utama
sebagai induk dari aktivitas kedua. Kemudian Anda akan memodifikasi onClick event method di
aktivitas utama untuk memasukkan Intent yang meluncurkan aktivitas kedua ketika Anda mengklik
button.
Praktikum 4.2. Membuat dan meluncurkan aktivitas kedua

# Membuat aktivitas kedua
1. Klik folder aplikasi untuk proyek Anda dan pilih File > New >
Activity > Empty Activity.
106
2. Beri nama aktivitas baru "AktivitasKedua" Pastikan Generate

Layout File dicentang, dan nama layout akan diisi dengan
“aktivitas_kedua”.
3. Klik Finish. Android Studio akan menambahkan layout aktivitas
baru (aktivitas_kedua) dan file Java baru (AktivitasKedua) ke
proyek Anda untuk aktivitas baru. Ini juga memperbarui manifest
Android untuk memasukkan aktivitas baru.
# Membuat aktivitas kedua

4. Buka manifests/AndroidManifest.xml.
5. Temukan elemen <activity> yang dibuat Android Studio untuk
aktivitas kedua.
<activity android:name=".AktivitasKedua"></activity>
6. Tambahkan atribut ini ke elemen <activity>:

1 android:label "Aktivitas Kedua"
2 android:parentActivityName ".MainActivity"
• Atribut label menambahkan judul aktivitas ke action bar.

• Atribut parentActivityName menunjukkan bahwa aktivitas utama
adalah induk dari aktivitas kedua.
• Hubungan aktivitas orang tua ini digunakan untuk navigasi
"ke atas" dalam aplikasi Anda. Dengan mendefinisikan atribut
ini, action bar untuk aktivitas kedua akan muncul dengan
panah menghadap ke kiri untuk memungkinkan pengguna
menavigasi "ke atas" ke aktivitas utama.
7. Tempatkan kursor pada "Aktivitas Kedua" dan tekan Alt-Enter

(Option-Enter pada Mac).
8. Pilih Extract string resource, beri nama sumber daya
"aktivitas2_nama", dan klik OK.
107
Android Studio menambahkan sumber daya string untuk label

aktivitas.
9. Tambahkan elemen <meta-data> di dalam elemen <activity> untuk
aktivitas kedua. Gunakan atribut ini:

1 android:name "android.support.PARENT_ACTIVITY"
2 android:value "com.example.tekomduaaktivitas.MainActivity"
• Elemen <meta-data> menyediakan informasi arbitrer tambahan

tentang aktivitas sebagai pasangan nilai kunci.
• Dalam hal ini, atribut ini mencapai hal yang sama dengan
atribut android: parentActivityName - atribut tersebut
menetapkan hubungan antara dua aktivitas untuk tujuan
navigasi ke atas.
• Atribut ini diperlukan untuk Android versi lama. android:
parentActivityName hanya tersedia untuk level API 16 dan
lebih tinggi.
# Membuat layout untuk aktivitas kedua
10. Buka res/layout/aktivitas_kedua.xml dan ubah grup tampilan

root menjadi RelativeLayout, seperti yang Anda lakukan pada
latihan sebelumnya.
11. Tambahkan sebuah TextView (“Plain TextView”) dengan atribut
sebagai berikut:

1 android:id "@+id/text_header"
2 android:layout_width wrap_content
3 android:layout_height wrap_content
4 android:layout_marginBottom "@dimen/activity_vertical_margin"
5 android:text "Pesan Diterima"
6 android:textAppearance "?android:attr/textAppearanceMedium"
7 android:textStyle "bold"
108
Nilai textAppearance adalah atribut tema Android khusus yang

mendefinisikan gaya font dasar untuk font kecil, sedang, dan
besar.
12. Extract string "Pesan Diterima" ke sumber daya bernama

text_header.
13. Preview layout di Editor Layout. Tampilan akan seperti di
bawah ini:
# Menambahkan Intent pada Aktivitas Utama
Dalam praktikum ini Anda akan menambahkan Intent eksplisit ke

aktivitas utama. Intent ini digunakan untuk mengaktifkan aktivitas
kedua ketika Button Kirim diklik.
14. Buka file MainActivity.java

15. Buat Intent baru dalam method luncurkanAktivitaskedua().
Konstruktor Intent mengambil dua argumen untuk Intent
eksplisit: Konteks aplikasi dan komponen spesifik yang akan
109
menerima Intent itu. Di sini Anda harus menggunakan this sebagai

konteks, dan AktivitasKedua.class sebagai kelas spesifik.
Intent Intent = new Intent(this, SecondActivity.class);
16. Tempatkan kursor pada Intent dan tekan Alt-Enter (Option-

Enter pada Mac) untuk menambahkan impor untuk kelas Intent.
17. Panggil method startActivity() dengan Intent baru sebagai
argumen.
startActivity(Intent);
18. Jalankan aplikasi.

Ketika Anda mengklik tombol Kirim aktivitas utama mengirimkan
Intent dan sistem Android meluncurkan aktivitas kedua.
Aktivitas kedua itu muncul di layar. Untuk kembali ke aktivitas
utama, klik tombol Android Back di bagian kiri bawah layar,
atau Anda dapat menggunakan panah kiri di bagian atas aktivitas
kedua untuk kembali ke aktivitas utama.
Pada prkatikum sebelumnya, Anda menambahkan Intent eksplisit ke aktivitas utama yang
mengaktifkan aktivitas kedua. Anda juga dapat menggunakan Intent untuk mengirim data dari satu
aktivitas ke aktivitas lainnya.
Dalam tugas ini, Anda akan memodifikasi Intent eksplisit dalam aktivitas utama untuk
memasukkan data tambahan (dalam hal ini, string yang dimasukkan pengguna) dalam ekstra Intent.
Anda kemudian akan memodifikasi aktivitas kedua untuk mendapatkan kembali data dari ekstra
Intent dan menampilkannya di layar.
Praktikum 4.3. Mengirim data dari aktivitas utama ke aktivitas kedua

# Menambahkan sebuah EditText pada layout MainActivity
1. Buka res/layout/activity_main.xml.
2. Tambahkan tampilan EditText (Teks Biasa di Editor Layout.)
Berikan EditText atribut ini:
110
1 android:id "@+id/editText_main"
2 android:layout_width match_parent
4 android:layout_toLeftOf "@+id/button_main"
5 android:layout_toStartOf "@+id/button_main"
6 android:layout_alignParentBottom "true"
7 android:hint "Masukkan pesan anda di
sini!"
3. Extract string "Masukkan Pesan Anda Di Sini" ke sumber daya

bernama editText_main.
4. Preview aktivitas utama seperti nampak pada gambar berikut:
# Menambahkan sebuah string kepada Intent ekstra aktivitas utama
Objek Intent Anda dapat meneruskan data ke aktivitas target dengan

dua cara: dalam data field, atau di ekstra Intent. Data Intent
adalah URI yang menunjukkan data spesifik yang akan
ditindaklanjuti. Jika informasi yang ingin Anda sampaikan ke
aktivitas melalui Intent bukan URI, atau Anda memiliki lebih dari
111
satu informasi yang ingin Anda kirim, Anda bisa memasukkan

informasi tambahan itu ke ekstra Intent.
Ekstra Intent adalah pasangan kunci / nilai dalam suatu Bundel.
Bundel adalah kumpulan data, disimpan sebagai pasangan kunci /
nilai. Untuk meneruskan informasi dari satu aktivitas ke aktivitas
lainnya, Anda memasukkan kunci dan nilai ke dalam bundel ekstra
Intent dari aktivitas pengiriman, dan kemudian mengeluarkannya
kembali dalam aktivitas penerimaan.
Lanjutkan langkah berikut:

5. Buka MainActivity.java
6. Tambahkan konstanta publik di bagian atas kelas untuk
mendefinisikan kunci untuk Intent ekstra:
public static final String EXTRA_MESSAGE =

"com.example.android.twoactivities.extra.MESSAGE";
7. Tambahkan sebuah variable private pada bagian atas kelas untuk

menampung objek EditText. Import kelas EditText.
private EditText mMessageEditText;
8. Dalam metode onCreate(), gunakan findViewByID untuk mendapatkan

referensi ke instance EditText dan menugaskannya ke variabel
private:
mMessageEditText = (EditText)
findViewById(R.id.editText_main);
9. Dalam metode luncurkanAktivitaskedua(), tepat di bawah new

Intent, dapatkan teks dari EditText sebagai string:
String message = mMessageEditText.getText().toString();
112
10. Tambahkan string itu ke Intent sebagai ekstra dengan

konstanta EXTRA_MESSAGE sebagai kunci dan string sebagai
nilainya:
Intent.putExtra(EXTRA_MESSAGE, message);
# Menambahkan seuah TextView kepada aktivitas kedua untuk pesan
11. Buka aktivitas_kedua.xml.

12. Tambahkan TextView kedua dan berikan TextView tersebut
dengan atribut ini:

1 android:id "@+id/text_message"
4 android:layout_below "@+id/text_header"
5 android:layout_marginLeft "@dimen/activity_horizontal_margin"
6 android:layout_marginStart "@dimen/activity_horizontal_margin"
7 android:textAppearance "?android:attr/textAppearanceMedium"
Layout baru untuk aktivitas kedua terlihat sama seperti di tugas

sebelumnya, karena TextView baru tidak (belum) mengandung teks
apa pun, dan karenanya tidak muncul di layar.
# Memodifikasi aktifitas kedua untuk mendapatkan ekstra dan pesan
13. Buka AktivitasKedua.java

14. Dalam metode onCreate(), dapatkan Intent yang mengaktifkan
aktivitas ini:
Intent Intent = getIntent();
15. Dapatkan string berisi pesan dari ekstra Intent menggunakan

variabel statis MainActivity.EXTRA_MESSAGE sebagai kunci:
113
String message =
Intent.getStringExtra(MainActivity.EXTRA_MESSAGE);
16. Gunakan findViewByID untuk mendapatkan referensi ke

TextView untuk pesan dari layout (Anda mungkin perlu mengimpor
kelas TextView):
TextView TextView =
(TextView)findViewById(R.id.text_message);
17. Setel teks TextView itu ke string dari Intent ekstra:
TextView.setText(message);
18. Jalankan aplikasi. Saat Anda mengetik pesan di aktivitas

utama dan klik Kirim, aktivitas kedua diluncurkan dan
menampilkan pesan itu.
Sekarang Anda memiliki aplikasi yang meluncurkan aktivitas baru dan mengirimkan data
ke sana, langkah terakhir adalah mengembalikan data dari aktivitas kedua kembali ke aktivitas
utama. Anda juga akan menggunakan Intent dan ekstra Intent untuk tugas ini.
Praktikum 4.4. Mengembalikan data kembali ke aktivitas utama

# Menambahkan sebuah EditText dan Button pada layout Aktivitas
Kedua
1. Salin EditTeks dan Tombol dari file layout activity_main.xml

dan tempel ke layout aktivitas_kedua.xml.
2. Dalam file aktivitas_kedua.xml, ubah nilai atribut untuk
tampilan Button dan EditText.
Gunakan nilai-nilai ini:
No Atribut Button (lama) Atribut Button (baru)

1 android:id="@+id/button_main" android:id="@+id/button_kedua"
114
2 android:onClick= android:onClick="kembalikanBalasan"
"launchSecondActivity"
3 android:text= android:text= "@string/button_kedua"
"@string/button_main"
No Atribut EditText (lama) Atribut EditText (baru)

1 android:id="@+id/editText_main" android:id="@+id/editText_kedua"
2 android:layout_toLeftOf= android:layout_toLeftOf=
"@+id/button_main" "@+id/button_second"
3 android:layout_toStartOf= android:layout_toStartOf=
"@+id/button_main" "@+id/button_kedua"
4 android:hint= android:hint=
"@string/editText_main" "@string/editText_kedua"
3. Buka res/values/strings.xml dan tambahkan sumber string untuk

teks tombol dan petunjuk di EditText:
<string name="button_kedua">Balas</string>
<string name="editText_kedua"> Masukkan pesan balasan di sini!
</string>
4. Di editor layout XML, tempatkan kursor pada

"kembalikanBalasan", tekan Alt-Enter (Option-Enter pada Mac)
dan pilih Buat ‘kembalikanBalasan(view)' di
'AktivitasKedua.java'.
File AktivitasKedua.java terbuka, dan Android Studio
menghasilkan metode kerangka untuk penangan onClick secara
otomatis. Layout baru untuk aktivitas kedua terlihat seperti
ini:
115
# Membuat Intent respon pada aktivitas kedua
5. Buka AktivitasKedua.java
6. Di bagian atas kelas, tambahkan konstanta publik untuk
mendefinisikan kunci untuk Intent ekstra:
public static final String EXTRA_REPLY =

"com.example.android.twoactivities.extra.REPLY";
7. Tambahkan variabel private di bagian atas kelas untuk memegang

objek EditText.
private EditText mReply;
8. Dalam metode onCreate(), gunakan findViewByID () untuk

mendapatkan referensi ke instance EditText dan menetapkannya ke
variabel private:
mReply = (EditText) findViewById(R.id.editText_second);
116
9. Dalam metode kembalikanBalasan(), dapatkan teks dari EditText

sebagai string:
String reply = mReply.getText().toString();
10. Buat Intent baru untuk respons.
Intent replyIntent = new Intent();
11. Tambahkan string balasan dari EditText ke Intent baru

sebagai Intent ekstra. Karena ekstra adalah pasangan kunci /
nilai, di sini kuncinya adalah EXTRA_REPLY dan nilainya adalah
balasan:
setResult(RESULT_OK,replyIntent);
12. Panggil finish() untuk menutup aktivitas dan kembali ke

aktivitas utama.
finish();
# Menambahkan TextView ke layout aktivitas utama untuk menampilkan

balasan
Aktivitas utama membutuhkan cara untuk menampilkan balasan yang

dikirim kembali dari aktivitas kedua. Dalam tugas ini Anda akan
menambahkan TextView ke layout aktivitas utama untuk menampilkan
balasan itu. Untuk mempermudah ini, Anda akan menyalin TextView
yang Anda gunakan dalam aktivitas kedua.
13. Salin dua TextView untuk tampilan pesan dari file layout
aktivitas kedua dan tempelkan ke layout utama di atas EditText
dan Button view yang ada.
14. Ubah nilai atribut untuk kedua TextView baru ini. Gunakan
nilai-nilai ini:
117
No Atribut Header TextView Atribut Header TextView(baru)

(lama)
1 android:id="@+id/text_header" android:id="@+id/text_header_reply"
2 android:text= android:text=
"@string/text_header" "@string/text_header_reply"
No Atribut Pesan TextView Atribut Pesan TextView (baru)

(lama)
1 android:id="@+id/text_message" android:id="@+id/text_message_reply"
15. Tambahkan atribut android: visibilitas ke masing-masing dari

TextViews untuk membuat mereka awalnya tidak terlihat.
(Membuatnya terlihat di layar, tetapi tanpa konten apa pun,
dapat membingungkan pengguna.) Anda akan membuat TextViews ini
terlihat setelah data respons dilewatkan kembali dari aktivitas
kedua.
android:visibility="invisible"
16. Buka res/values/strings.xml dan tambahkan sumber daya string

untuk header balasan:
<string name=" text_header_balasan">Pesan balasan

diterima</string>
Layout untuk aktivitas utama terlihat sama seperti pada tugas

sebelumnya - meskipun Anda telah menambahkan dua TextView baru
ke layout. Namun, karena Anda mengatur TextView menjadi tidak
terlihat, mereka tidak muncul di layar.
# Mendapatkan balasan dari Intent ekstra dan menampilkannya
Saat Anda menggunakan Intent eksplisit untuk memulai aktivitas

lain, Anda mungkin tidak berharap mendapatkan data apa pun - Anda
118
hanya mengaktifkan aktivitas itu. Dalam hal ini, Anda menggunakan

startActivity() untuk memulai aktivitas baru, seperti yang Anda
lakukan sebelumnya dalam pelajaran ini. Namun, jika Anda ingin
mendapatkan kembali data dari aktivitas yang diaktifkan, Anda
harus memulainya dengan startActivityFromResult().
Dalam tugas ini Anda akan memodifikasi aplikasi untuk memulai
aktivitas kedua dan mendapatkan hasil, untuk mengekstrak data yang
dikembalikan dari Intent, dan untuk menampilkan data itu di
TextViews yang Anda buat di praktikum sebelumnya. Salin dua
TextViews untuk tampilan pesan dari file layout aktivitas kedua
dan tempelkan ke layout utama di atas EditText dan Button view
yang ada.
17. Buka MainActivity.java

18. Tambahkan konstanta publik di bagian atas kelas untuk
menentukan kunci untuk jenis respons tertentu yang Anda minati:
public static final int TEXT_REQUEST = 1;
19. Tambahkan dua variabel private untuk mendapatkan reply

header dan TextView reply:
private TextView mReplyHeadTextView;

private TextView mReplyTextView;
20. Dalam metode onCreate(), gunakan findViewByID untuk

mendapatkan referensi dari layout ke header balasan dan balas
TextView. Tetapkan instance tampilan tersebut ke variabel
private:
mReplyHeadTextView = (TextView)
findViewById(R.id.text_header_reply);
mReplyTextView = (TextView)
findViewById(R.id.text_message_reply);
119
21. Dalam metode luncurkanAktivitaskedua(), ubah panggilan

untuk startActivity() menjadi startActivityForResult(), dan
sertakan kunci TEXT_REQUEST sebagai argumen:
startActivityForResult(Intent, TEXT_REQUEST);
22. Buat metode panggilan balik onActivityResult() dengan tanda

tangan ini:
public void onActivityResult(int requestCode, int resultCode,

Intent data) {}
23. Inside onActivityResult(), call super.onActivityResult():
super.onActivityResult(requestCode, resultCode, data);
24. Tambahkan kode untuk menguji TEXT_REQUEST (untuk memproses

hasil Intent yang benar, jika ada beberapa) dan RESULT_CODE
(untuk memastikan permintaan berhasil):
if (requestCode == TEXT_REQUEST) {
if (resultCode == RESULT_OK) {
}
}
25. Di bagian dalam blok if, dapatkan Intent ekstra dari Intent
respons (data). Di sini kunci untuk ekstra adalah konstanta
EXTRA_REPLY dari AktivitasKedua:
String reply =
data.getStringExtra(SecondActivity.EXTRA_REPLY);
26. Setel visibilitas header balasan ke true:
mReplyHeadTextView.setVisibility(View.VISIBLE);
120
27. Tetapkan teks tampilan teks balasan ke balasan, dan

tetapkan visibilitasnya menjadi true:
mReplyTextView.setText(reply);
mReplyTextView.setVisibility(View.VISIBLE);
28. Jalankan aplikasi.

Sekarang, ketika Anda mengirim pesan ke aktivitas kedua dan
mendapatkan balasan, aktivitas utama memperbarui untuk
menampilkan balasan.
121
Output Praktikum 4.
Berdasarkan praktikum yang telah Anda kerjakan, lengkapi isian
berikut:
• Screenshot layer smartphone pengiriman pesan dari aktivitas
utama ke aktivitas kedua.
Tempel screenshot dari

Tempel screenshot Layout
smartphone Aktivitas utama
Aktivitas kedua di sini
di sini
• Screenshot layer smartphone balasan pesan dari aktivitas kedua

ke aktivitas utama

di sini
• Kode java aktivitas utama dan aktivitas kedua
Kode Aktivitas utama di sini Kode aktivitas kedua di sini
• Kode XML aktivitas utama dan aktivitas kedua
122
• Kode android manifest dan sumberdaya string
Kode android manifest di

Kode string.xml di sini
sini
Latihan 4.1. Analisis masalah

1. Apa yang terjadi jika anda menghapus android:parentActivityName
dan elemen pada <meta-data> dari manifest? Tuliskan dan
jelaskan jawaban dan hasil analisis anda pada tempat yang telah
disediakan
Jawaban:
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………………………………………………………………….………………………………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………….………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………………………………………….……………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………..………………………………….
123
Latihan 4.2.
1. Buat aplikasi dengan tiga tombol berlabel: Teks Satu, Teks Dua,
dan Teks Tiga. Ketika salah satu dari tombol itu diklik, maka
aktivitas kedua diluncurkan. Aktivitas kedua tersebut harus
berisi ScrollView yang menampilkan salah satu dari tiga kalimat
teks (teks yang ditampilkan berbeda, tergantung pada tombol
yang ditekan). Gunakan Intent untuk meluncurkan aktivitas kedua
dan ekstra intent untuk menunjukkan yang mana dari ketiga
kalimat yang akan ditampilkan.
Jawaban:
utama ke aktivitas kedua (button 1).

di sini


di sini

124

di sini
• Kode java aktivitas utama dan aktivitas kedua
• Kode XML aktivitas utama dan aktivitas kedua

sini
125
Latihan 4.3.
1. Modifikasi project yang anda kerjakan pada praktikum di atas.
Buat aplikasi dengan tiga tombol yang akan mengirimkan 3 pesan
ke tiga aktivitas berbeda tergantung pada tombol yang ditekan.
Kemudian dari aktivitas yang tampil kembali akan dikirimkan
pesan balasan yang akan ditampilkan pada aktivitas utama.
Jawaban:

di sini

utama ke aktivitas ketiga (button 2).

di sini
126

utama ke aktivitas keempat (button 3).

di sini

kedua/ ketiga/ keempat ke aktivitas utama.

di sini
• Kode java aktivitas utama aktivitas kedua
127
• Kode java aktivitas ketiga dan aktivitas keempat
Kode aktivitas keempat di

Kode Aktivitas ketiga di sini
sini
• Kode XML aktivitas utama dan aktivitas ketiga
Kode Aktivitas utama di sini Kode aktivitas ketiga di sini

sini
128
B. Memahami Siklus Hidup Aktifitas dan Status Siklus

Siklus hidup aktivitas (Activity Lifecycle) adalah serangkaian keadaan yang dapat dilakukan
oleh suatu aktivitas selama masa penggunaannya dalam sistem, dari saat awalnya dibuat hingga saat
dihancurkan dan sistem mengklaim kembali sumber daya aktivitas tersebut. Saat pengguna
menavigasi antara aktivitas di aplikasi Anda (serta masuk dan keluar dari aplikasi Anda), aktivitas
tersebut melakukan perpindahan status yang berbeda dalam siklus hidup aktivitas. Adapun gambaran
siklus hidup aktivitas dapat dilihat pada gambar berikut:
Gambar 4.2. Siklus hidup aktivitas
Setiap tahap dalam siklus hidup suatu kegiatan memiliki metode callback yang sesuai
(onCreate (), onStart (), onPause (), dan sebagainya). Ketika suatu aktivitas berubah status, metode
callback terkait dipanggil. Pada program sebelumnya yang telah dikerjakan, Anda telah melihat
salah satu metode ini: onCreate (). Dengan menimpa salah satu metode callback siklus hidup di
kelas aktivitas Anda, Anda dapat mengubah perilaku default bagaimana perilaku aktivitas Anda
dalam menanggapi pengguna atau sistem dengan aksi berbeda.
Perubahan pada status aktivitas juga dapat terjadi sebagai respons terhadap perubahan
konfigurasi perangkat seperti memutar perangkat dari potret ke lanskap. Perubahan konfigurasi ini
menghasilkan aktivitas yang dihancurkan dan seluruhnya diciptakan kembali dalam keadaan
default, yang dapat menyebabkan hilangnya informasi yang dimasukkan pengguna dalam aktivitas
itu. Sangat penting untuk mengembangkan aplikasi Anda untuk mencegah hal ini untuk
menghindari kebingungan pengguna. Selanjutnya dalam praktik ini kita akan bereksperimen
dengan perubahan konfigurasi dan mempelajari cara mempertahankan status aktivitas Anda
sebagai respons terhadap perubahan konfigurasi perangkat atau peristiwa siklus hidup Aktivitas
lainnya.
129
Dalam praktik ini, Anda akan menambahkan pernyataan logging ke aplikasi DuaAktivitas
yang telah dikerjakan sebelumnya pada bagian A dan mengamati perubahan siklus hidup saat Anda
menggunakan aplikasi dengan berbagai cara.
Anda kemudian akan mulai bekerja dengan perubahan ini dan menjelajahi cara menangani
input pengguna dalam kondisi ini.
Praktikum 4.5. Menambahkan Callback Siklus Hidup pada Project DuaAktivitas

19. Buka project yang telah anda selesaikan dengan benar pada
bagian A (Praktikum 4.1-4.4)
20. Buka MainActivity.Java
21. Pada method onCreate()tambahkan statement berikut.
Log.d(LOG_TAG,"------------Saat ini dalam fase: ----------");

Log.d(LOG_TAG,"onCreate");
22. Tambahkan method baru untuk callback onStart(), dengan

statement untuk log fase ini.
@Override
protected void onStart() {
super.onStart();
Log.d(LOG_TAG,"--------Saat ini dalam fase: ------");
Log.d(LOG_TAG,"onStart");
}
Pilih Code> Override Methods in Android Studio. Maka sebuah

kotak dialog muncul dengan semua metode yang mungkin Anda bisa
override di kelas Anda. Memilih satu atau lebih metode callback
dari daftar maka sistem akan menyisipkan templat lengkap untuk
metode-metode tersebut, termasuk panggilan yang diperlukan ke
superclass.
23. Gunakan method onStart() sebagai template untuk

mengimplementasikan callback siklus hiup lainnya (onPause(),
onRestart(), onResume(), onStop(), onDestroy())
130
24. Sesuaikan pesan yang akan ditampilkan dengan metode callback

yang akan dieksekusi.
25. Jalankan aplikasi pada perangkat atau emulator anda.
26. Ouput yang akan anda lihat pada logcat kurang lebih seperti
berikut:
Output Praktikum 4.5

berikut:
• Screenshot pesan pada logcat saat aplikasi baru dibuka
Tempel screenshot logcat di

sini!
• Aktifkan rotasi perangkatmu, Screenshot pesan pada logcat saat

aplikasi dibuka dan saat posisi smartphonemu berubah dari
portrait ke landscape
131

sini!
• Screenshot pesan pada logcat saat aplikasi ditutup

sini!
• Tuliskan (BUKAN DIKETIK) dan jelaskan satu persatu kapan setiap

fase siklus hidup yang muncul pada logcat praktikum ini
dilakukan pada suatu aktivitas? Jelaskan pula apa maksud dari
setiap fase tersebut.
Jawaban:
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………………………………………………………………….………………………………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………….………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………………………………………….……………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………..………………………………….……………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………….……………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………….…………………
…………………………………………………………………………………………………………………………………
132
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
………………………………………………………………………………….…………………………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
……………………………………….……………………………………………………………………………………
……………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………….…
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………..……………………
…………….………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………….……………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
…………………………………………………….………………………………………………………………………
Praktikum 4.6. Menambahkan Callback Siklus Hidup pada AktivitasKedua.java

1. Buka AktivitasKedua.Java
2. Pada bagian atas kelas tambahkan sebuah constant untuk variable
LOG_TAG
private static final String

LOG_TAG=AktivitasKedua.class.getSimpleName();
3. Tambahkan callback siklus hidup dan statement log pada

aktivitas kedua. Lakukan sama seperti pada aktivitas utama.
4. Pada method kembalikanBalasan(), tambahkan sebuah statement log
tepat diatas sebelum method finish()
Log.d(LOG_TAG,"Mengakhiri Aktivitas Kedua");
5. Jalankan aplikasi pada emulator atau perangkat anda

6. Tampilkan logcat pada layer Android Studio
133
7. Lakukan beberapa percobaan berikut dan amati serta pahami

fase siklus hidup yang terjadi
• Gunakan aplikasi secara normal (kirim pesan dan balas
pesan)
• Gunakan tombol back untuk kembali dari aktivitas kedua ke
aktivitas utama
• Gunakan tombol panah kembali pada action bar untuk kembali
dari aktivitas kedua ke aktivitas utama
• Rotasi perangkat anda pada kedua aktivitas
• Tekan tombol overview (tombol yang berda di dekat tombol
home) dan keluar dari aplikasi
• Kembali ke layer home lalu kembali masuk ke aplikasi
8. Pada search box, ketikkan Activity sehingga semua pesan log
yang kita harapkan dapat terlihat tanpa bercampur dengan log
lainnya yang sedang berjalan.

• Fase apa saja yang terjadi pada saat anda menggunakan aplikasi
secara normal (kirim pesan dan balas pesan) Berikan centang
fase yang terjadi pada bagian yang telah disediakan berikut
ini:
Aktivitas Utama Aktivitas Kedua

onCreate() onStart() onCreate() onStart()
onPause() onStop() onPause() onStop()
onRestart() onResume() onRestart() onResume()
onDestroy() onDestroy()
• Fase apa saja yang terjadi pada saat anda menggunakan tombol
back untuk kembali dari aktivitas kedua ke aktivitas utama

134

• Fase apa saja yang terjadi pada saat anda menggunakan panah
kembali pada Action Bar untuk kembali dari aktivitas kedua ke
aktivitas utama

• Fase apa saja yang terjadi pada saat anda merotasi perangkat
anda pada kedua aktifitas

• Saat anda merotasi perangkat pada aktivitas utama, apakah

pesan balasan yang dikirim dari aktivitas kedua tetap tampil
pada aktivitas utama?
Tampil Tidak Tampil / Hilang
• Fase apa saja yang terjadi pada saat anda menekan tombol
overview (tombol yang berda di dekat tombol home) dan tombol
keluar dari aplikasi
135

• Fase apa saja yang terjadi pada saat anda kembali ke home
screen perangkat anda lalu kembali masuk ke aplikasi

Bergantung pada sumber daya sistem dan perilaku pengguna, aktivitas di aplikasi Anda
mungkin dihancurkan dan direkonstruksi jauh lebih sering daripada yang Anda bayangkan. Anda
mungkin telah memperhatikan serangkaian aktivitas ini di bagian terakhir ketika Anda memutar
perangkat atau emulator. Memutar perangkat adalah salah satu contoh perubahan konfigurasi
perangkat. Meskipun rotasi adalah yang paling umum, semua perubahan konfigurasi mengakibatkan
aktivitas saat ini dihancurkan dan diciptakan kembali seolah-olah itu baru. Jika Anda tidak
memperhitungkan perilaku ini dalam kode Anda, ketika perubahan konfigurasi terjadi, tata letak
aktivitas Anda dapat kembali ke tampilan default dan nilai awal, dan pengguna Anda mungkin
kehilangan tempat, data mereka, atau keadaan kemajuan mereka dalam aplikasi Anda.
Keadaan masing-masing aktivitas disimpan sebagai satu set pasangan kunci / nilai dalam
objek Bundel yang disebut activity instance state. Sistem menyimpan informasi status default ke
bundel keadaan instance tepat sebelum aktivitas dihentikan, dan meneruskan bundel itu ke instance
aktivitas baru untuk dipulihkan.
Agar tidak kehilangan data dalam aktivitas Anda saat dihancurkan dan dibuat ulang secara
tak terduga, Anda perlu menerapkan metode onSaveInstanceState (). Sistem memanggil metode ini
pada aktivitas Anda (antara onPause () dan onStop ()) ketika ada kemungkinan aktivitas tersebut
dapat dihancurkan dan diciptakan kembali.
Data yang Anda simpan dalam keadaan instance hanya spesifik untuk instance aktivitas
khusus ini selama sesi aplikasi saat ini. Saat Anda berhenti dan memulai kembali sesi aplikasi baru,
136
status instance aktivitas hilang dan aktivitas Anda akan kembali ke tampilan defaultnya. Jika Anda
perlu menyimpan data pengguna di antara sesi aplikasi, gunakan preferensi bersama atau database.
Anda mungkin telah memperhatikan bahwa memutar perangkat tidak mempengaruhi
kondisi aktivitas kedua sama sekali. Ini karena tata letak dan status aktivitas kedua dihasilkan dari
tata letak dan intent yang mengaktifkannya. Bahkan jika aktivitas diciptakan kembali, intent masih
ada dan data dalam intent itu masih digunakan setiap kali fase onCreate () aktivitas kedua dipanggil.
Selain itu, Anda mungkin memperhatikan bahwa dalam kedua aktivitas tersebut, teks apa
pun yang Anda ketikkan ke dalam pesan atau balas EditTeks tetap dipertahankan meskipun
perangkat diputar. Ini karena informasi keadaan beberapa tampilan dalam tata letak Anda secara
otomatis disimpan di seluruh perubahan konfigurasi, dan nilai EditText saat ini adalah salah satu dari
kasus tersebut.
Satu-satunya status aktivitas yang Anda mungkin perlu perhatikan dengan baik adalah
TextViews untuk header balasan dan teks balasan di aktivitas utama. Kedua TextViews tidak terlihat
secara default; mereka hanya muncul setelah Anda mengirim pesan kembali ke aktivitas utama dari
aktivitas kedua. Saat anda merotasi perangkat anda, data yang ditampilkan hilang. Dalam praktikum
berikut ini Anda akan menambahkan kode untuk mempertahankan keadaan instance dari dua
TextViews ini menggunakan onSaveInstanceState ().
Praktikum 4.7. Menyimpan keadaan instance aktivitas dengan onSaveInstanceState()

1. Buka MainActivity.Java
2. Tambahkan implementasi kerangka onSaveInstanceState() ke
aktivitas, atau gunakan Code > Override Methods untuk
menambahkan skeleton override.
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
Ingat bahwa header dan teks balasan ditandai tidak terlihat

sampai ada balasan dari aktivitas kedua. Jika headernya
terlihat, maka ada data balasan yang perlu disimpan. Kita hanya
perlu memperhatikan status visibilitas itu - teks sebenarnya
dari header tidak perlu disimpan, karena teks itu tidak pernah
berubah.
137
3. Dalam pengecekan (struktur if) yang sama, tambahkan teks

balasan pada bundle.
outState.putString("reply_text",mReplyTextView.getText().toS
tring());
Jika header terlihat, Anda dapat mengasumsikan bahwa pesan

balasan itu sendiri juga terlihat. Anda tidak perlu menguji atau
menyimpan status visibilitas saat ini dari pesan balasan. Hanya
teks pesan yang masuk ke bundel status dengan kunci
"reply_text". Kita hanya menyimpan keadaan view yang mungkin
berubah setelah aktivitas dibuat. Tampilan lain di aplikasi Anda
(EditTeks, Tombol) dapat dibuat ulang dari tata letak default
kapan saja.
Setelah Anda menyimpan keadaan instance aktivitas, Anda juga harus mengembalikannya
saat aktivitas dibuat ulang. Anda bisa melakukan ini di onCreate(), atau dengan
mengimplementasikan callbak onRestoreInstanceState(), yang dipanggil setelah onStart() setelah
aktivitas dibuat. Akan lebih baik untuk memulihkan status aktivitas di onCreate(), untuk memastikan
bahwa antarmuka pengguna Anda termasuk keadaan tersedia sesegera mungkin. Kadang-kadang
nyaman untuk melakukannya di onRestoreInstanceState () setelah semua inisialisasi telah dilakukan,
atau untuk memungkinkan subkelas untuk memutuskan apakah akan menggunakan implementasi
default Anda.
Praktikum 4.8. Mengembalikan activity instance state dalam onCreate()

1. Masih pada MainActivity.Java, pada method onCreate() tambahkan
sebuah proses pengecekan untuk memastikan bundle tidak kosong
if(savedInstanceState!=null){
}
Saat aktivitas Anda dibuat, sistem meneruskan bundel status ke

onCreate () sebagai satu-satunya argumen. Pertama kali onCreate
138
() dipanggil dan aplikasi Anda mulai, bundel itu nol - tidak

ada keadaan yang ada saat pertama kali aplikasi Anda dimulai.
Panggilan selanjutnya ke onCreate () memiliki bundel yang diisi
dengan data apa pun yang Anda simpan di onSaveInstanceState ().
2. Pada proses pengecekan tersebut dapatkan visibiltas saat ini

(benar atau salah) dari bundle dengan kunci “reply_visible”
if(savedInstanceState!=null){
boolean isVisible =
savedInstanceState.getBoolean("reply_visible");
}
3. Tambahkan pengujian di bawah baris sebelumnya untuk variable

isVisible
if (isVisible){
}
Jika ada kunci reply_visible dalam bundel status (dan isVisible

benar), kita perlu mengembalikan status.
4. Di dalam tes isVisible, buat header terlihat (visible).
mReplyHeadTextView.setVisibility(View.VISIBLE);
5. Dapatkan pesan balasan teks dari bundel dengan kunci

"reply_text", dan atur balasan TextView untuk menampilkan
string itu.
mReplyTextView.setText(savedInstanceState.getString("reply_t
ext"));
6. Jadikan textView untuk pesan balasan juga visible
139
mReplyTextView.setVisibility(View.VISIBLE);
7. Jalankan aplikasi pada perangkat anda. Coba rotasikan perangkat

anda dari portrait ke landscapeuntuk memastikan bahwa pesan
tetap ada walaupun aktivitas dimulai kembali.

• Saat anda merotasi perangkat pada aktivitas utama, apakah
pesan balasan yang dikirim dari aktivitas kedua tetap tampil
pada aktivitas utama?
Tampil Tidak Tampil / Hilang
C. Aktivitas dan Intent Ipmlisit

Di bagian sebelumnya Anda belajar tentang intent eksplisit - mengaktifkan aktivitas spesifik
di aplikasi Anda atau aplikasi lain dengan mengirimkan intent dengan nama kelas yang sepenuhnya
memenuhi syarat untuk aktivitas itu. Di bagian ini Anda akan belajar lebih banyak tentang intent
implisit, dan bagaimana Anda bisa menggunakannya untuk mengaktifkan aktivitas juga.
Intent tersirat memungkinkan Anda untuk mengaktifkan suatu aktivitas jika Anda
mengetahui tindakan tersebut, tetapi bukan aplikasi atau aktivitas spesifik yang akan menangani
tindakan itu. Misalnya, jika Anda ingin aplikasi mengambil foto, atau mengirim email, atau
menampilkan lokasi pada peta, Anda biasanya tidak peduli aplikasi atau aktivitas spesifik mana yang
benar-benar melakukan tindakan ini.
Sebaliknya, aktivitas Anda dapat mendeklarasikan satu atau beberapa filter intent dalam
manifes Android yang mengiklankan kemampuan aktivitas tersebut untuk menerima intent implisit
dan untuk menentukan jenis intent tertentu yang akan diterimanya.
Untuk mencocokkan permintaan Anda dengan aplikasi spesifik yang diinstal pada
perangkat, sistem Android mencocokkan intent implisit Anda dengan aktivitas yang filter intentnya
menunjukkan bahwa mereka dapat melakukan tindakan itu. Jika ada beberapa aplikasi yang diinstal
yang cocok, pengguna disajikan dengan pemilih aplikasi yang memungkinkan mereka memilih
aplikasi mana yang ingin mereka gunakan untuk menangani intent itu.
140
Dalam praktik ini Anda akan membangun aplikasi yang mengirimkan tiga intent implisit:
untuk membuka URL di browser web, untuk membuka lokasi di peta, dan untuk membagikan sedikit
teks.
Berbagi - mengirim sepotong informasi kepada orang lain melalui email atau media sosial -
adalah fitur yang umum dan populer di banyak aplikasi. Untuk tindakan berbagi, kita akan
menggunakan kelas ShareCompat.IntentBuilder, yang memudahkan untuk membangun intent untuk
berbagi data.
Terakhir, kita akan membuat aplikasi penerima intent sederhana yang menerima intent
implisit untuk tindakan tertentu.
Praktikum 4.9. Membuat project baru dan layout

Nama Aplikasi :“Namapanggilanmu”ImplisitIntent

Language :Java
Template :Empty Activity
1. Modifikasi string.xml dengan kode berikut
<string
name="edittext_uri">http://developer.android.com</string>
<string name="button_uri">Open Website</string>
<string name="edittext_loc">Golden Gate Bridge</string>

<string name="button_loc">Open Location</string>
<string name="edittext_share">\'Twas brillig and the

slithy toves</string>
<string name="button_share">Share This Text</string>
2. Konversi layout menjadi LinearLayout. Tambahkan atribut

android:orientation dan berikan nilai “vertical”.
141
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.example.android.implicitintents.MainActiv
ity"
android:orientation="vertical">
3. Hilangkan text “hello world”

4. Tambahkan sebuah EditText dan sebuah Button ke dalam layout
untuk membuka fungsi website. Gunakan nilai beikut:
No Attribut (EditeText) Value (EditText)

1 android:id "@+id/website_edittext"
2 android:layout_width "match_parent"
3 android:layout_height "wrap_content"
4 android:text "@string/edittext_uri"
No Attribut (Button) Value (Button)

1 android:id "@+id/open_website_button"
2 android:layout_width "wrap_content"
4 android:layout_marginBottom "24dp"
5 android:text "@string/button_uri"
6 android:onClick "openWebsite"
5. Tambahkan EditText kedua dan sebuah Button untuk fungsi membuka

lokasi

1 android:id "@+id/location_edittext"
142
4 android:text "@string/edittext_loc"

1 android:id "@+id/open_location_button"
5 android:text "@string/button_loc"
6 android:onClick "openLocation"
6. Tambahkan EditText ketiga dan sebuah Button untuk fungsi

berbagi pesan

1 android:id "@+id/share_edittext"
4 android:text "@string/edittext_share"

1 android:id "@+id/share_text_button"
5 android:text "@string/button_share"
6 android:onClick "shareText"
7. Setelah mengetikkan kode XML dengan benar maka tampilan preview

layout aplikasi Nampak seperti gambar berikut:
143

berikut:
Tempel screenshot Tempel kode

mainActivity.xml di sini! mainActivity.xml di sini!
Praktikum 4.10. Mengimplementasikan “Open Website”

1. Modifikasi MainActivity.java
menampung object editText untuk URI website
private EditText mWebsiteEditText;
144
3. Pada method onCreate(), gunakan finViewById() untuk mendapatkan

reference ke instance EditText dan kemudian tugaskan ke dalam
sebuah variable priivat berikut:
mWebsiteEditText = (EditText)
findViewById(R.id.website_edittext);
4. Buatlah sebuah method baru bernama openWebsite()
public void openWebsite(View view) { }
5. Dapatkan nilai string dari mWebsiteEditText EditText
String url = mWebsiteEditText.getText().toString();
6. Encode dan parsing nilai string tersebut menjadi object URI
Uri webpage = Uri.parse(url);
7. Buatlah sebuah intent dengan intent.ACTION_VIEW sebagai aksi

dan URL sebagai data.
Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
Konstruktor intent ini berbeda dari yang Anda gunakan untuk

membuat intent eksplisit. Di konstruktor sebelumnya, Anda
menentukan konteks saat ini dan komponen tertentu (kelas
aktivitas) untuk mengirim intent. Di konstruktor ini Anda
menentukan tindakan dan data untuk tindakan itu. Tindakan
didefinisikan oleh kelas Intent dan dapat mencakup ACTION_VIEW
(untuk melihat data yang diberikan), ACTION_EDIT (untuk mengedit
data yang diberikan), atau ACTION_DIAL (untuk memutar nomor
telepon). Dalam hal ini tindakannya adalah ACTION_VIEW karena
kami ingin membuka dan melihat halaman web yang ditentukan oleh
URI dalam variabel halaman web.
145
8. Gunakan resolActivity () dan pengelola paket Android untuk

menemukan aktivitas yang dapat menangani intent tersirat Anda.
Periksa untuk memastikan permintaan itu berhasil diselesaikan.
if (intent.resolveActivity(getPackageManager()) != null) {
}
Permintaan yang cocok dengan tindakan dan data intent Anda

dengan filter intent untuk aplikasi yang diinstal pada perangkat
untuk memastikan setidaknya ada satu aktivitas yang dapat
menangani permintaan Anda.
9. Di dalam if-statement, panggil startActivity () untuk mengirim

maksud.
startActivity(intent);
10. Tambahkan blok lain untuk mencetak pesan log jika intentnya
tidak dapat diselesaikan.
else {
Log.d("ImplicitIntents", "Can't handle this!");
}
11. Jadi kode setelah diketikkan seharusnya terlihat seperti

ini:
public void openWebsite(View view) {

// Get the URL text.
String url = mWebsiteEditText.getText().toString();
// Parse the URI and create the intent.

Uri webpage = Uri.parse(url);
146
Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
// Find an activity to hand the intent and start that

activity.
if (intent.resolveActivity(getPackageManager()) != null)
{
} else {
Log.d("ImplicitIntents", "Can't handle this
intent!");
}
}
Praktikum 4.11. Mengimplementasikan “Open Location”

menampung object editText untuk URI website
private EditText mLocationEditText;
3. Pada method onCreate(), gunakan finViewById() untuk mendapatkan

reference ke instance EditText dan kemudian tugaskan ke dalam
sebuah variable priivat berikut:
mLocationEditText = (EditText)
findViewById(R.id.location_edittext);
4. Buatlah sebuah method baru bernama openLocation()
public void openLocation(View view) { }
147
5. Dapatkan nilai string dari mLocationEditText EditText
String loc = mLocationEditText.getText().toString();
6. Parsing nilai string tersebut menjadi object URI dengan query

pencarian geografis
Uri addressUri = Uri.parse("geo:0,0?q=" + loc);
7. Buatlah sebuah intent dengan intent.ACTION_VIEW sebagai aksi

dan URL sebagai data.
Intent intent = new Intent(Intent.ACTION_VIEW, addressUri);
8. Perbaiki masalah pada intent dan periksa apakah intent

diselesaikan dengan sukses atau tidak. Jika ya, maka
startActivity(), jika tidak tampilkan log dengan pesan error.
if (intent.resolveActivity(getPackageManager()) != null) {
} else {
Log.d("ImplicitIntents", "Can't handle this intent!");
}
12. Jadi kode setelah diketikkan seharusnya terlihat seperti

ini:
public void openLocation(View view) {

// Get the string indicating a location. Input is not
validated; it is
// passed to the location handler intact.
String loc = mLocationEditText.getText().toString();
// Parse the location and create the intent.

Uri addressUri = Uri.parse("geo:0,0?q=" + loc);
148
Intent intent = new Intent(Intent.ACTION_VIEW,

addressUri);
// Find an activity to handle the intent, and start that

activity.
if (intent.resolveActivity(getPackageManager()) != null)
{
} else {
Log.d("ImplicitIntents", "Can't handle this
intent!");
}
}
Praktikum 4.12. Mengimplementasikan “Share Text”

14. Tambahkan sebuah variable private pada bagian atas kelas
untuk menampung object editText untuk URI website
private EditText mShareTextEditText;
15. Pada method onCreate(), gunakan finViewById() untuk

mendapatkan reference ke instance EditText dan kemudian
tugaskan ke dalam sebuah variable priivat berikut:
mShareTextEditText = (EditText)
findViewById(R.id.share_edittext);
16. Buatlah sebuah method baru bernama shareThis()
public void shareThis(View view) { }
149
17. Dapatkan nilai string dari mShareTextEditText EditText
String txt = mShareTextEditText.getText().toString();
18. Defenisikan tipe mime dari text yang akan dishare
String mimeType = "text/plain";
19. Panggil ShareCompat.IntentBuilder dengan method berikut:
ShareCompat.IntentBuilder
.from(this)
.setType(mimeType)
.setChooserTitle("Share this text with: ")
.setText(txt)
.startChooser();
Panggilan ke ShareCompat.IntentBuilder ini menggunakan metode

ini:
</tr> </table> Format ini, dengan semua metode setter pembuat
dirangkai dalam satu pernyataan, adalah cara cepat yang mudah
untuk membuat dan meluncurkan intent. Anda dapat menambahkan
salah satu metode tambahan ke daftar ini.
No Metode Deskripsi
1 from() Aktivitas yang melucurkan intent share saat ini
(this).
2 setType() Tipe MIME dari item yang akan dishare.
3 setChooserTitle() Judul yang muncul pada system pemilihan app.
4 setText() Text actual yang akan dishare.
5 startChooser() Menampilkan system pemilihan app dan mengirimkan
intent.
20. Jadi kode setelah diketikkan seharusnya terlihat seperti ini:
150
public void shareText(View view) {

String txt = mShareTextEditText.getText().toString();
String mimeType = "text/plain";
ShareCompat.IntentBuilder
.from(this)
.setType(mimeType)
.setChooserTitle("Share this text with: ")
.setText(txt)
.startChooser();
}
21. Setelah semua kode pada MainActivity.java dieksekusi maka

ketika anda menekan salah satu tombol misalnya open location,
aplikasi akan menampilkan beberapa aplikasi lainnya yang dapat
memproses intent anda
151
Output Praktikum 4.10 - 4.12

berikut:
• Screenshot tampilan yang muncul setelah mengkklik tombol
“Open Website”
Tempel screenshot tampilan

setelah mengklik tombol

“Open Location”


“Share This Text”

Sejauh ini, Anda telah membuat aplikasi yang menggunakan intent eksplisit dan implisit
untuk meluncurkan beberapa aktivitas aplikasi lain. Dalam praktikum berikut ini kita akan melihat
152
masalah dari sebaliknya: memungkinkan aktivitas di aplikasi Anda untuk menanggapi intent implisit
yang dikirim dari beberapa aplikasi lain.
Aktivitas di aplikasi Anda selalu dapat diaktifkan dari dalam atau di luar aplikasi Anda
dengan intent eksplisit. Untuk mengizinkan suatu kegiatan menerima intent implisit, Anda
menetapkan filter intent dalam manifes Anda untuk menunjukkan intent implisit mana yang tertarik
untuk ditangani oleh aktivitas Anda.
Untuk mencocokkan permintaan Anda dengan aplikasi spesifik yang diinstal pada
perangkat, sistem Android mencocokkan intent implisit Anda dengan aktivitas yang filter intentnya
menunjukkan bahwa mereka dapat melakukan tindakan itu.
Jika ada beberapa aplikasi yang diinstal yang cocok, pengguna disajikan dengan pemilih
aplikasi yang memungkinkan mereka memilih aplikasi mana yang ingin mereka gunakan untuk
menangani intent itu.
Ketika sebuah aplikasi pada perangkat mengirimkan intent implisit, sistem Android
mencocokkan tindakan dan data intent itu dengan aktivitas yang tersedia yang menyertakan filter
intent yang benar. Jika filter intent aktivitas Anda cocok dengan intent, aktivitas Anda dapat
menangani intent itu sendiri (jika itu satu-satunya aktivitas yang cocok), atau (jika ada beberapa yang
cocok) pemilih aplikasi muncul untuk memungkinkan pengguna untuk memilih aplikasi mana yang
mereka inginkan.
Dalam praktikum berikut ini Anda akan membuat aplikasi yang sangat sederhana yang
menerima intent implisit untuk membuka URI untuk halaman web.
Saat diaktifkan oleh intent tersirat, aplikasi itu menampilkan URI yang diminta sebagai
string di TextView.
Praktikum 4.13. Membuat project penerima intent (layout)

Nama Aplikasi :“Namapanggilanmu”ImplisitIntentReceiver

Language :Java
Template :Empty Activity
2. Modifikasi TextView yang sudah ada dengan nilai berikut
No Attribut Value
1 android:id "@+id/text_uri_message"
153
4 android:textSize "18sp"
5 android:textStyle "bold"
3. Hapus attribute android:text, tidak ada teks di TextView ini

secara default, tetapi Anda akan menambahkan URI dari maksud
di onCreate().
Praktikum 4.14. Membuat project penerima intent (andoirdmanifest)

1. Buka AndroidManifest.xml
2. Perhatikan bahwa pada MainActivity telah memiliki filtent
berikut ini:
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"
/>
</intent-filter>
Filter intent ini merupakan bagian dari project manifest ini

menunjukkan bahwa aktivitas ini adalah titik masuk utama untuk
aplikasi anda (memiliki aktivitas intent
"android.intent.action.MAIN"), dan bahwa aktivitas ini akan
muncul sebagai item tingkat atas dalam peluncur (kategorinya
adalah "android.intent.category.LAUNCHER")
3. Tambahkan intent filter <intent-filter> kedua dan tag didalam

<activity>, masukkan elemen berikut ini
<action android:name="android.intent.action.VIEW" />

<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE"
/>
154
<data android:scheme="http"
android:host="developer.android.com" />
Baris-baris ini mendefinisikan filter intent untuk aktivitas,

yaitu jenis intent yang dapat ditangani oleh aktivitas. Filter
intnet ini menyatakan elemen-elemen ini:
No Tipe Nilai Tujuan
Filter
1 Action "android.intent.action.VIEW" Semua intent dengan
view action
2 Category "android.intent.category.DEFAULT" Semua intent
implisit. Kategori
ini harus diikutkan
untuk aktivitas anda
untuk menerima intent
implisit apapun
3 Category "android.intent.category.BROWSABLE" Meminta untuk link
browsable dari
halaman web, email,
dan sumber daya
lainnya
4 data android:scheme="http" URI yang mengandung
android:host="developer.android.com" skema http dan sebuah
host name dari
developer.android.com
Perhatikan bahwa filter data memiliki batasan pada jenis

tautan yang akan diterima dan nama host untuk URI tersebut.
Jika Anda ingin penerima Anda dapat menerima tautan apa pun,
Anda dapat mengabaikan elemen <data />
4. Setelah diketikkan bagian tag application android manifest

seharusnya Nampak seperti kode di bawah ini :
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
155
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action
android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
<intent-filter>
<action
android:name="android.intent.action.VIEW" />
<category
android:name="android.intent.category.DEFAULT" />
<category
android:name="android.intent.category.BROWSABLE" />
<data android:scheme="http"
android:host="developer.android.com" />
</intent-filter>
</activity>
</application>
Dalam metode onCreate () untuk aktivitas Anda, Anda memproses intent yang masuk untuk
setiap data atau tambahan yang disertakan. Dalam hal ini, maksud tersirat masuk memiliki URI
disimpan dalam data Intent.
Praktikum 4.16. Membuat project penerima intent (memproses intent)

1. Pada project yang sama buka MainActivity.java
2. Pada method onCreate() dapatkan intent yang masuk yang akan
digunakan untuk mengaktifkan aktivitas.
156
Intent intent = getIntent();
3. Dapatkan data intent. Data intent selalu dalam bentuk object

URI.
Uri uri = intent.getData();
4. Periksa untuk memastikan apakah variable uri tidak kosong (not

null) jika pengecekan ini dilewati/lolos, buat string dari
object URI
if (uri != null) {
String uri_string = "URI: " + uri.toString();
}
5. Di dalam block if yang sama, dapatkan object textview untuk

pesan yang akan ditampilkan
TextView textView = (TextView)

findViewById(R.id.text_uri_message);
6. Masih di dalam blok if yang sama, atur text dari TextView ke

URI
textView.setText(uri_string);
7. Jalankan applikasi receiver

Menjalankan aplikasi sendiri menunjukkan aktivitas kosong tanpa
teks. Ini karena aktivitas diaktifkan dari peluncur sistem, dan
bukan dengan intent dari aplikasi lain.
8. Jalankan aplikasi dengan inten implisit, dan klik open website

dengan default URI
Pemilih aplikasi muncul menanyakan apakah Anda ingin
menggunakan browser default atau aplikasi
157
ImplicitIntentsReceiver. Pilih "Hanya Sekali" untuk aplikasi

penerima. Aplikasi ImplicitIntentsReceiver diluncurkan dan
pesan menunjukkan URI dari permintaan awal.
9. Tekan tombol back, dan masukkan URI yang lain, lalu klik open
website
Aplikasi penerima memiliki filter intent sangat terbatas yang
hanya cocok dengan protokol URI (http) dan host
(developer.android.com). URI lain terbuka di browser web
default.

berikut:
• Screenshot tampilan aplikasi intent receiver yang muncul
setelah mengklik tombol “Open Website” pada aplikasi
implisit intent

158

Modul Pemrograman Mobile BAB IV 2021

Diunggah oleh

Informasi Dokumen

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

Modul Pemrograman Mobile BAB IV 2021

Diunggah oleh

Hak Cipta:

Format Tersedia

MODUL PEMROGRAMAN MOBILE DENGAN ANDROID STUDIO – ANDI BASO KASWAR

Gambar 4.1. Ilustrasi aktivitas pada suatu aplikasi

A. Membuat dan memulai aktivitas

Praktikum 4.1. Membuat Proyek Dua Aktivitas

1. Buatlah sebuah project baru dengan ketentuan berikut:

Nama Aplikasi :“Namapanggilanmu”DuaAktivitas

# Membuat layout untuk aktivitas utama

4. Pada Layout Editor, klik tab Design di bagian bawah layar.

# Membuat layout untuk aktivitas utama

No Nama atribut Nilai

Atribut di atas mungkin akan menampilkan error bahwa "Method

8. Tempatkan kursor pada kata "Kirim".

13. Pada Editor XML, tempatkan kursor pada kata

Log.d(LOG_TAG, "Tombol ditekan!");

16. LOG_TAG akan ditampilkan sebagai error. Definisi untuk

private static final String LOG_TAG =

Konstanta ini menggunakan nama kelas itu sendiri sebagai tag.

Jalankan aplikasi Anda. Ketika Anda mengklik tombol "Kirim" Anda

Praktikum 4.2. Membuat dan meluncurkan aktivitas kedua

2. Beri nama aktivitas baru "AktivitasKedua" Pastikan Generate

# Membuat aktivitas kedua

6. Tambahkan atribut ini ke elemen <activity>:

No Nama atribut Nilai

• Atribut label menambahkan judul aktivitas ke action bar.

7. Tempatkan kursor pada "Aktivitas Kedua" dan tekan Alt-Enter

Android Studio menambahkan sumber daya string untuk label

No Nama atribut Nilai

• Elemen <meta-data> menyediakan informasi arbitrer tambahan

# Membuat layout untuk aktivitas kedua

10. Buka res/layout/aktivitas_kedua.xml dan ubah grup tampilan

No Nama atribut Nilai

Nilai textAppearance adalah atribut tema Android khusus yang

12. Extract string "Pesan Diterima" ke sumber daya bernama

# Menambahkan Intent pada Aktivitas Utama

Dalam praktikum ini Anda akan menambahkan Intent eksplisit ke

14. Buka file MainActivity.java

menerima Intent itu. Di sini Anda harus menggunakan this sebagai

Intent Intent = new Intent(this, SecondActivity.class);

16. Tempatkan kursor pada Intent dan tekan Alt-Enter (Option-

18. Jalankan aplikasi.

Praktikum 4.3. Mengirim data dari aktivitas utama ke aktivitas kedua

3. Extract string "Masukkan Pesan Anda Di Sini" ke sumber daya

# Menambahkan sebuah string kepada Intent ekstra aktivitas utama

Objek Intent Anda dapat meneruskan data ke aktivitas target dengan

satu informasi yang ingin Anda kirim, Anda bisa memasukkan

Lanjutkan langkah berikut:

public static final String EXTRA_MESSAGE =

7. Tambahkan sebuah variable private pada bagian atas kelas untuk

private EditText mMessageEditText;

8. Dalam metode onCreate(), gunakan findViewByID untuk mendapatkan

9. Dalam metode luncurkanAktivitaskedua(), tepat di bawah new

String message = mMessageEditText.getText().toString();

10. Tambahkan string itu ke Intent sebagai ekstra dengan

# Menambahkan seuah TextView kepada aktivitas kedua untuk pesan

11. Buka aktivitas_kedua.xml.

No Nama atribut Nilai

Layout baru untuk aktivitas kedua terlihat sama seperti di tugas

# Memodifikasi aktifitas kedua untuk mendapatkan ekstra dan pesan

13. Buka AktivitasKedua.java

Intent Intent = getIntent();

15. Dapatkan string berisi pesan dari ekstra Intent menggunakan

16. Gunakan findViewByID untuk mendapatkan referensi ke

17. Setel teks TextView itu ke string dari Intent ekstra:

18. Jalankan aplikasi. Saat Anda mengetik pesan di aktivitas