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

1
 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.
# 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:
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 =

 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.
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>:

No Nama atribut Nilai

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.
 Android Studio menambahkan sumber daya string untuk label
aktivitas.
9. Tambahkan elemen <meta-data> di dalam elemen <activity> untuk
aktivitas kedua. Gunakan atribut ini:

No Nama atribut Nilai

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:

No Nama atribut Nilai

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"
 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
 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:
No Nama atribut Nilai
 1 android:id "@+id/editText_main"
2 android:layout_width match_parent
3 android:layout_height wrap_content
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
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();

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:

No Nama atribut Nilai

1 android:id "@+id/text_message"
2 android:layout_width wrap_content
3 android:layout_height wrap_content
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:
 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"
 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:
# 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);

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:
 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
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);
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);
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.
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

Tempel screenshot dari

Tempel screenshot Layout smartphone Aktivitas utama
Aktivitas kedua di sini
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

 Kode Aktivitas utama di sini Kode aktivitas kedua di sini

 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:

…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………………………………………………………………….………………………………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………….………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………………………………………….……………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………..………………………………….
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:
 Screenshot layer smartphone pengiriman pesan dari aktivitas
utama ke aktivitas kedua (button 1).

Tempel screenshot dari

Tempel screenshot Layout
smartphone Aktivitas utama Aktivitas kedua di sini
di sini

 Screenshot layer smartphone pengiriman pesan dari aktivitas

utama ke aktivitas kedua (button 2).

Tempel screenshot dari

Tempel screenshot Layout
smartphone Aktivitas utama Aktivitas kedua di sini
di sini

 Screenshot layer smartphone pengiriman pesan dari aktivitas

utama ke aktivitas kedua (button 3).
 Tempel screenshot dari
Tempel screenshot
smartphone Aktivitas
Layout Aktivitas kedua
utama di sini
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

Kode Aktivitas utama di sini Kode aktivitas kedua di sini

 Kode android manifest dan sumberdaya string

Kode android manifest di

Kode string.xml di sini
sini
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:
 Screenshot layer smartphone pengiriman pesan dari aktivitas
utama ke aktivitas kedua (button 1).

Tempel screenshot dari

Tempel screenshot Layout
smartphone Aktivitas utama Aktivitas kedua di sini
di sini

 Screenshot layer smartphone pengiriman pesan dari aktivitas

utama ke aktivitas ketiga (button 2).

Tempel screenshot dari

Tempel screenshot
smartphone Aktivitas
Layout Aktivitas kedua
utama di sini
di sini
 Screenshot layer smartphone pengiriman pesan dari aktivitas
utama ke aktivitas keempat (button 3).

Tempel screenshot dari

Tempel screenshot
smartphone Aktivitas
Layout Aktivitas kedua
utama di sini
di sini

 Screenshot layer smartphone pengiriman pesan dari aktivitas

kedua/ ketiga/ keempat ke aktivitas utama.

Tempel screenshot dari

Tempel screenshot
smartphone Aktivitas
Layout Aktivitas kedua
utama di sini
di sini

 Kode java aktivitas utama aktivitas kedua

Kode Aktivitas utama di sini Kode aktivitas kedua di sini

 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

 Kode android manifest dan sumberdaya string

Kode android manifest di

Kode string.xml di sini
sini
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.
 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())
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

Berdasarkan praktikum yang telah Anda kerjakan, lengkapi isian
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
 Tempel screenshot logcat
di sini!

 Screenshot pesan pada logcat saat aplikasi ditutup

Tempel screenshot logcat

di 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:

…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………………………………………………………………….………………………………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
……………….………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………………………………………….……………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………………………………..………………………………….……………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
………………………………….……………………………………………………………………………………………
…………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………….…………………
…………………………………………………………………………………………………………………………………
 ……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
………………………………………………………………………………….…………………………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
……………………………………….……………………………………………………………………………………
……………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………….…
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………..……………………
…………….………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………….……………………………
……………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………
…………………………………………………….………………………………………………………………………

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
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.

Output Praktikum 4.6

 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

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 panah
kembali pada Action Bar untuk kembali dari aktivitas kedua ke
aktivitas utama

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 merotasi perangkat
anda pada kedua aktifitas

Aktivitas Utama Aktivitas Kedua

□ onCreate() □ onStart() □ onCreate() □ onStart()
□ onPause() □ onStop() □ onPause() □ onStop()
□ onRestart() □ onResume() □ onRestart() □ onResume()
□ onDestroy() □ □ onDestroy()

 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
 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 kembali ke home
screen perangkat anda lalu kembali masuk ke aplikasi

Aktivitas Utama Aktivitas Kedua

□ onCreate() □ onStart() □ onCreate() □ onStart()
□ onPause() □ onStop() □ onPause() □ onStop()
□ onRestart() □ onResume() □ onRestart() □ onResume()
□ onDestroy() □ □ onDestroy()

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,
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.
 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
 () 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

 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.

Output Praktikum 4.8

 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.
 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

1. Buatlah sebuah project baru dengan ketentuan berikut:

Nama Aplikasi :“Namapanggilanmu”ImplisitIntent

Language :Java
Minimum API level :API 16: Android 4.1 (Jelly Bean)
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”.
<LinearLayout
android:layout_width="match_parent" android:layout_height="match_parent" android:paddingBottom="@dimen
android:paddingTop="@dimen/activity_vertical_margin"

tools:context="co
android:orientati

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"
3 android:layout_height "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

No Attribut (EditeText) Value (EditText)

1 android:id "@+id/location_edittext"
 2 android:layout_width "match_parent"
3 android:layout_height "wrap_content"
4 android:text "@string/edittext_loc"

No Attribut (Button) Value (Button)

1 android:id "@+id/open_location_button"
2 android:layout_width "wrap_content"
3 android:layout_height "wrap_content"
4 android:layout_marginBottom "24dp"
5 android:text "@string/button_loc"
6 android:onClick "openLocation"

6. Tambahkan EditText ketiga dan sebuah Button untuk fungsi

berbagi pesan

No Attribut (EditeText) Value (EditText)

1 android:id "@+id/share_edittext"
2 android:layout_width "match_parent"
3 android:layout_height "wrap_content"
4 android:text "@string/edittext_share"

No Attribut (Button) Value (Button)

1 android:id "@+id/share_text_button"
2 android:layout_width "wrap_content"
3 android:layout_height "wrap_content"
4 android:layout_marginBottom "24dp"
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:
Output Praktikum 4.9
Berdasarkan praktikum yang telah Anda kerjakan, lengkapi isian
berikut:

Tempel screenshot Tempel kode

mainActivity.xml di mainActivity.xml di
sini! sini!

Praktikum 4.10. Mengimplementasikan “Open Website”

1. Modifikasi MainActivity.java
2. Tambahkan sebuah variable private pada bagian atas kelas untuk
menampung object editText untuk URI website

private EditText mWebsiteEditText;

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.
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);
 Intent intent = new Intent(Intent.ACTION_VIEW, webpage);

// Find an activity to hand the intent and start that activity.

if (intent.resolveActivity(getPackageManager()) != null)
{
startActivity(intent);
} else {
Log.d("ImplicitIntents", "Can't handle this intent!");
}
}

Praktikum 4.11. Mengimplementasikan “Open Location”

1. Modifikasi MainActivity.java
2. Tambahkan sebuah variable private pada bagian atas kelas untuk
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) { }

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) {
startActivity(intent);
} 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);
 Intent intent = new Intent(Intent.ACTION_VIEW,
addressUri);

// Find an activity to handle the intent, and start that activity.

if (intent.resolveActivity(getPackageManager()) != null)
{
startActivity(intent);
} else {
Log.d("ImplicitIntents", "Can't handle this intent!");
}
}

Praktikum 4.12. Mengimplementasikan “Share Text”

13. Modifikasi MainActivity.java
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) { }

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:

 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
 Output Praktikum 4.10 - 4.12
Berdasarkan praktikum yang telah Anda kerjakan, lengkapi isian
berikut:
 Screenshot tampilan yang muncul setelah mengkklik tombol
“Open Website”

Tempel screenshot tampilan

setelah mengklik tombol

 Screenshot tampilan yang muncul setelah mengkklik tombol

“Open Location”

Tempel screenshot tampilan

setelah mengklik tombol

 Screenshot tampilan yang muncul setelah mengkklik tombol

“Share This Text”

Tempel screenshot
tampilan setelah
mengklik tombol

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
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)

1. Buatlah sebuah project baru dengan ketentuan berikut:

Nama Aplikasi :“Namapanggilanmu”ImplisitIntentReceiver

Language :Java
Minimum API level :API 16: Android 4.1 (Jelly Bean)
Template :Empty Activity

2. Modifikasi TextView yang sudah ada dengan nilai berikut

No Attribut Value
1 android:id "@+id/text_uri_message"
 2 android:layout_width wrap_content
3 android:layout_height wrap_content
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"
/>
 <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"
 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.
 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
 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.

Output Praktikum 4.16

Berdasarkan praktikum yang telah Anda kerjakan, lengkapi isian
berikut:
 Screenshot tampilan aplikasi intent receiver yang muncul
setelah mengklik tombol “Open Website” pada aplikasi
implisit intent

Tempel screenshot
tampilan setelah
mengklik tombol