Kursus Android Gratis Tutorial Terlengkap Belajar Android Programming #2

2.1: Memahami Aktivitas dan Maksud

 

Dalam bab ini Anda akan mempelajari tentang aktivitas, blok pembangunan utama antarmuka pengguna aplikasi, serta penggunaan maksud untuk berkomunikasi di antara aktivitas.

Tentang aktivitas

Aktivitas menyatakan layar tunggal di aplikasi Anda dengan antarmuka yang bisa digunakan pengguna untuk berinteraksi. Misalnya, aplikasi email mungkin memiliki satu aktivitas yang menampilkan daftar email baru, aktivitas lain untuk menulis email, dan aktivitas lainnya lagi untuk membaca pesan satu per satu. Aplikasi Anda adalah koleksi aktivitas yang dibuat sendiri atau yang digunakan kembali dari aplikasi lain.

Meskipun aktivitas di aplikasi Anda bekerja sama membentuk pengalaman pengguna yang kohesif di aplikasi, setiap aplikasi tidak saling bergantung. Proses ini memungkinkan aplikasi memulai aktivitas di aplikasi lainnya, dan aplikasi lainnya bisa memulai aktivitas Anda (jika aplikasi mengizinkannya). Misalnya, aplikasi perpesanan yang Anda tulis bisa memulai aktivitas di aplikasi kamera untuk mengambil gambar, kemudian memulai aktivitas di aplikasi email untuk memungkinkan pengguna berbagi gambar itu di email.Aplikasi Anda bisa memulai aktivitas yang berbeda

Umumnya, satu aktivitas di aplikasi ditetapkan sebagai aktivitas “utama”, yang disajikan kepada pengguna saat membuka aplikasi untuk pertama kali. Kemudian setiap aktivitas bisa memulai aktivitas lainnya untuk melakukan tindakan yang berbeda.

Setiap kali aktivitas baru dimulai, aktivitas sebelumnya akan dihentikan, namun sistem mempertahankan aktivitas dalam tumpukan (“back-stack”). Bila pengguna selesai dengan aktivitas saat ini dan menekan tombol Kembali, aktivitas akan muncul dari tumpukan (dan dimusnahkan) dan aktivitas sebelumnya dilanjutkan.

Bila aktivitas dihentikan karena aktivitas baru dimulai, aktivitas pertama akan diberi tahu tentang perubahan tersebut dengan metode callback daur hidup aktivitas. Daur hidup Aktivitas adalah serangkaian keadaan aktivitas, mulai dari pertama kali dibuat, hingga setiap kali dihentikan atau dilanjutkan, hingga bila sistem memusnahkannya. Anda akan mengetahui selengkapnya tentang daur hidup aktivitas di bab berikutnya.

Membuat aktivitas

Untuk mengimplementasikan aktivitas di aplikasi Anda, lakukan yang berikut ini:

  • Buat kelas Java aktivitas.
  • Implementasikan antarmuka pengguna untuk aktivitas itu.
  • Deklarasikan aktivitas baru itu di manifes aplikasi.

Bila Anda membuat proyek baru untuk aplikasi atau menambahkan aktivitas baru ke aplikasi, di Android Studio (dengan File > New > Activity), kode template untuk setiap tugas ini akan disediakan untuk Anda.

Buat kelas aktivitas

Aktivitas adalah subkelas dari kelas Activity atau salah satu dari subkelasnya. Jika Anda membuat proyek baru di Android Studio, aktivitas tersebut secara default menjadi subkelas dari kelas AppCompatActivity. Kelas AppCompatActivity adalah subkelas Activity yang memungkinkan Anda menggunakan fitur aplikasi Android terbaru seperti bilah aksi dan desain material, sementara tetap memungkinkan aplikasi tersebut kompatibel dengan perangkat yang menjalankan Android versi lama.

Inilah subkelas kerangka dari aktivitas AppCompatActivity:

public class MainActivity extends AppCompatActivity {
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
   }
}

Tugas pertama Anda di subkelas aktivitas adalah mengimplementasikan metode callback daur hidup aktivitas standar (seperti OnCreate()) untuk menangani perubahan keadaan aktivitas. Perubahan keadaan ini meliputi hal-hal seperti kapan aktivitas dibuat, dihentikan, dilanjutkan, atau dimusnahkan. Anda akan mengetahui selengkapnya tentang daur hidup aktivitas dan callback daur hidup di bab berikutnya.

Salah satu callback yang diperlukan dan harus diimplementasikan oleh aplikasi Anda adalah metode onCreate(). Sistem memanggil metode ini bila membuat aktivitas, dan semua komponen penting aktivitas Anda harus melakukan diinisialisasi di sini. Yang paling penting, metode OnCreate() memanggil setContentView() untuk membuat layout utama aktivitas.

Anda biasanya mendefinisikan antarmuka pengguna untuk aktivitas di satu atau beberapa file layout XML. Bila metode setContentView() dipanggil dengan jalur ke file layout, sistem akan membuat semua tampilan awal dari layout yang ditetapkan dan menambahkannya ke aktivitas Anda. Hal ini sering kali disebut sebagai memekarkan layout.

Sering kali Anda mungkin juga ingin mengimplementasikan metode onPause() di kelas aktivitas. Sistem memanggil metode ini sebagai indikasi pertama bahwa pengguna meninggalkan aktivitas Anda (walaupun tidak selalu berarti aktivitas akan dimusnahkan). Di sinilah biasanya Anda harus mengikat perubahan yang harus dipertahankan di luar sesi pengguna saat ini (karena pengguna mungkin tidak akan kembali). Anda akan mengetahui selengkapnya tentang callback onPause() dan semua callback daur hidup lainnya di bab berikutnya.

Selain daur hidup callback, Anda juga bisa mengimplementasikan metode di aktivitas untuk menangani perilaku lainnya seperti masukan pengguna atau klik tombol.

Implementasikan antarmuka pengguna

Antarmuka pengguna untuk aktivitas disediakan menurut hierarki tampilan, yang mengontrol ruang tertentu dalam jendela aktivitas dan bisa merespons interaksi pengguna.

Cara yang paling umum untuk mendefinisikan antarmuka pengguna yang menggunakan tampilan adalah dengan file layout XML yang disimpan sebagai bagian dari sumber daya aplikasi Anda. Mendefinisikan layout di XML memungkinkan Anda untuk mengelola desain antarmuka pengguna secara terpisah dari kode sumber yang mendefinisikan perilaku aktivitas.

Anda juga bisa membuat tampilan baru secara langsung di kode aktivitas Anda dengan menyisipkan objek tampilan baru ke dalam ViewGroup, kemudian meneruskan ViewGroup akar ke setContentView(). Setelah layout dimekarkan — apa pun sumbernya — Anda bisa menambahkan lebih banyak tampilan di Java di mana saja dalam hierarki tampilan.

Deklarasikan aktivitas di manifes

Setiap aktivitas di aplikasi Anda harus dideklarasikan di manifes aplikasi Android bersama elemen <activity> , di dalam <application>. Bila Anda membuat proyek baru atau menambahkan aktivitas baru ke proyek di Android Studio, manifes akan dibuat atau diperbarui untuk menyertakan deklarasi aktivitas kerangka bagi setiap aktivitas. Inilah deklarasi untuk aktivitas utama.

<activity android:name=".MainActivity" >
   <intent-filter>
      <action android:name="android.intent.action.MAIN" />
      <category android:name="android.intent.category.LAUNCHER" />
   </intent-filter>
</activity>

Elemen <activity> menyertakan sejumlah atribut untuk mendefinisikan properti aktivitas seperti label, ikon, atau tema. Satu-satunya atribut yang diperlukan adalah android:name, yang menetapkan nama kelas aktivitas (seperti “MainActivity”). Lihat referensi elemen <activity> untuk informasi selengkapnya tentang deklarasi aktivitas.

Elemen <activity> juga bisa menyertakan deklarasi untuk filter maksud. Filter maksud menetapkan jenis maksud yang akan diterima aktivitas Anda.

 <intent-filter>
   <action android:name="android.intent.action.MAIN" />
   <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

Filter maksud harus menyertakan setidaknya satu elemen, dan juga bisa menyertakan sebuah danopsional. Aktivitas utama untuk aplikasi Anda memerlukan filter maksud yang mendefinisikan aksi “main” dan kategori “launcher” agar sistem bisa meluncurkan aplikasi. Android Studio membuat filter maksud ini untuk aktivitas utama di proyek Anda:

Elemen menetapkan bahwa ini adalah titik masuk “utama” ke aplikasi. Elemen menetapkan bahwa aktivitas ini harus tercantum dalam peluncur aplikasi sistem (untuk memungkinkan pengguna meluncurkan aktivitas ini).

Aktivitas lain di aplikasi Anda juga bisa mendeklarasikan filter maksud, namun hanya aktivitas utama yang harus menyertakan aksi “utama”. Anda akan mengetahui selengkapnya tentang maksud implisit dan filter maksud dalam bab berikutnya.

Tambahkan lebih banyak aktivitas ke proyek Anda

Aktivitas utama untuk aplikasi Anda dan file layout terkait disertakan bersama proyek bila Anda membuatnya. Anda bisa menambahkan aktivitas baru ke proyek di Android Studio dengan menu File > New > Activity. Pilih template aktivitas yang ingin Anda gunakan, atau buka Gallery untuk melihat semua template yang tersedia.Galeri Aktivitas di Android Studio

Bila memilih sebuah template aktivitas, Anda akan melihat serangkaian layar yang sama untuk membuat aktivitas baru yang dilakukan saat membuat proyek di awal. Android Studio menyediakan tiga hal ini untuk setiap aktivitas baru di aplikasi Anda:

  • File Java untuk aktivitas baru dengan definisi kelas kerangka dan metode onCreate(). Aktivitas baru, seperti aktivitas utama, adalah subkelas AppCompatActivity.
  • File XML yang berisi layout untuk aktivitas baru. Perhatikan, metode setContentView() di kelas aktivitas akan memerkarkan layout baru ini.
  • Elemen <activity> tambahan di manifes Android yang menetapkan aktivitas baru. Definisi aktivitas kedua tidak menyertakan filter maksud apa pun. Jika Anda ingin menggunakan aktivitas ini hanya dalam aplikasi (dan tidak memungkinkan aktivitas tersebut dimulai oleh aplikasi lain), maka tidak perlu menambahkan filter.

Tentang maksud

Semua aktivitas Android dimulai atau diaktifkan dengan maksud. Maksud adalah objek pesan yang membuat permintaan yang akan digunakan oleh waktu proses Android untuk memulai aktivitas atau komponen aplikasi lainnya di aplikasi Anda atau di beberapa aplikasi lainnya. Anda tidak bisa memulai aktivitas itu sendiri;

Bila aplikasi pertama kali dimulai dari layar utama perangkat, waktu proses Android akan mengirimkan maksud ke aplikasi Anda untuk memulai aktivitas utama aplikasi (yang didefinisikan dengan aksi MAIN dan kategori LAUNCHER di Manifes Android). Untuk memulai aktivitas lain di aplikasi Anda, atau meminta tindakan untuk dilakukan oleh beberapa aktivitas lain yang tersedia di perangkat, bangunlah maksud sendiri dengan kelas Intent dan panggil metode startActivity() untuk mengirim maksud itu.

Selain untuk memulai aktivitas, maksud juga digunakan untuk meneruskan data di antara aktivitas. Bila membuat maksud untuk memulai aktivitas baru, Anda bisa menyertakan informasi tentang data yang diinginkan untuk mengoperasikan aktivitas baru itu. Jadi, misalnya, aktivitas email yang menampilkan daftar pesan bisa mengirim maksud ke aktivitas yang menampilkan pesan itu. Aktivitas tampilan memerlukan data tentang pesan yang akan ditampilkan, dan Anda bisa menyertakan data itu di maksud.

Dalam bab ini, Anda akan mempelajari tentang penggunaan maksud bersama aktivitas, namun maksud juga digunakan untuk memulai layanan dan penerima siaran. Anda akan mempelajari tentang kedua komponen aplikasi itu nanti di buku ini.

Tipe maksud

Ada dua tipe maksud di Android:

  • Maksud eksplisit menetapkan aktivitas penerima (atau komponen lainnya) melalui nama kelas yang benar-benar memenuhi syarat di aktivitas tersebut. Gunakan maksud eksplisit untuk memulai komponen di aplikasi milik sendiri (misalnya, untuk beralih layar di antarmuka pengguna), karena Anda sudah mengetahui paket dan nama kelas komponen itu.
  • Maksud implisit tidak menetapkan aktivitas tertentu atau komponen lainnya untuk menerima maksud. Sebagai gantinya, Anda mendeklarasikan aksi umum yang dilakukan di maksud tersebut. Sistem Android mencocokkan permintaan Anda dengan aktivitas atau komponen lainnya yang bisa menangani aksi permintaan tersebut. Anda akan mengetahui selengkapnya tentang maksud implisit dalam bab berikutnya.

Objek dan bidang Intent

Objek Intent adalah instance kelas Intent. Untuk maksud eksplisit, bidang kunci suatu maksud menyertakan yang berikut ini:

  • Kelas aktivitas (untuk maksud eksplisit). Ini adalah nama kelas aktivitas atau komponen lainnya yang akan menerima maksud, misalnya, com.example.SampleActivity.class. Gunakan konstruktor maksud atau metode setComponent(), setComponentName() atau setClassName() maksud untuk menetapkan kelas.
  • Data maksud. Bidang data maksud berisi referensi ke data yang Anda inginkan untuk mengoperasikan aktivitas penerima, sebagai objek Uri.
  • Ekstra maksud. Ini adalah pasangan nilai-kunci yang membawa informasi yang diperlukan aktivitas penerima untuk melakukan aksi yang diminta.
  • Flag maksud. Ini adalah bit metadata tambahan, yang didefinisikan oleh kelas Intent. Flag dapat menginstruksikan sistem Android tentang cara meluncurkan aktivitas atau cara memperlakukan aktivitas setelah diluncurkan.

Untuk maksud implisit, Anda juga mungkin perlu mendefinisikan kategori dan aksi maksud. Anda akan mengetahui selengkapnya tentang kategori dan aksi maksud di bagian 2.3.

Memulai aktivitas dengan maksud eksplisit

Untuk memulai aktivitas tertentu dari aktivitas lain, gunakan maksud eksplisit dan metode startActivity(). Maksud eksplisit menyertakan nama kelas yang benar-benar memenuhi syarat untuk aktivitas atau komponen lainnya di objek Intent. Semua bidang maksud lainnya bersifat opsional, dan nol secara default.

Misalnya, jika Anda ingin memulai ShowMessageActivity untuk menampilkan pesan tertentu di aplikasi email, gunakan kode seperti ini.

Intent messageIntent = new Intent(this, ShowMessageActivity.class);
startActivity(messageIntent);

Konstruktor Intent menggunakan dua argumen untuk maksud eksplisit.

  • Konteks aplikasi. Dalam contoh ini, kelas aktivitas menyediakan materi (di sini, this).
  • Komponen tertentu untuk dimulai (ShowMessageActivity.class).

Gunakan metode startActivity() bersama objek maksud baru sebagai satu-satunya argumen. Metode startActivity() mengirim maksud ke sistem Android, yang meluncurkan kelas ShowMessageActivity atas nama aplikasi Anda. Aktivitas baru muncul pada layar dan aktivitas pembuatnya dihentikan sementara.

Aktivitas yang dimulai tetap pada layar hingga pengguna mengetuk tombol kembali pada perangkat, pada saat itu aktivitas ditutup dan diklaim kembali oleh sistem, dan aktivitas yang menghasilkannya akan dilanjutkan. Anda juga bisa menutup aktivitas yang dimulai secara manual sebagai respons terhadap aksi pengguna (seperti klik tombol) dengan metode finish():

public void closeActivity (View view) {
    finish();
}

Meneruskan data di antara aktivitas dengan maksud

Selain untuk memulai satu aktivitas dari aktivitas lain, Anda juga menggunakan maksud untuk meneruskan informasi di antara aktivitas. Objek maksud yang Anda gunakan untuk memulai aktivitas bisa menyertakan data maksud (URI objek untuk bertindak), atau ekstra maksud, yang merupakan bit data tambahan yang mungkin diperlukan aktivitas.

Di aktivitas (pengirim) pertama:

  1. Buat objek Intent.
  2. Masukkan data atau ekstra ke dalam maksud itu.
  3. Mulailah aktivitas baru dengan startActivity().

Di aktivitas (penerima) kedua:

  1. Dapatkan objek maksud yang digunakan memulai aktivitas.
  2. Ambil data atau ekstra dari objek Intent.

Waktu untuk menggunakan data maksud atau ekstra maksud

Anda bisa menggunakan data maksud dan ekstra maksud untuk meneruskan data di antara aktivitas. Ada sejumlah perbedaan utama antara data dan ekstra yang menentukan mana yang harus Anda gunakan.

Data maksud hanya bisa menyimpan satu bagian informasi. URI yang menyatakan lokasi data yang ingin Anda gunakan untuk mengoperasikan. URI tersebut bisa berupa URL laman web (http://), nomor telepon (tel://), lokasi geografis (geo://), atau URI khusus lainnya yang Anda definisikan.

Gunakan bidang maksud data:

  • Bila Anda hanya memiliki satu bagian informasi yang perlu dikirim ke aktivitas yang telah dimulai.
  • Bila informasi itu adalah lokasi data yang bisa dinyatakan dengan URI.

Ekstra maksud adalah untuk data arbitrer lainnya yang ingin Anda teruskan ke aktivitas yang telah dimulai. Ekstra maksud disimpan di objek Bundle sebagai pasangan kunci dan nilai. Bundle adalah peta, yang dioptimalkan untuk Android, dengan tombol berupa string, dan nilai-nilainya bisa berupa tipe objek atau primitif apa pun (objek harus mengimplementasikan antarmuka Parcelable). Untuk memasukkan data ke dalam ekstra maksud, Anda bisa menggunakan salah satu metode putExtra() kelas Intent, atau membuat bundel sendiri dan memasukkannya ke dalam maksud dengan putExtras().

Gunakan ekstra maksud:

  • Jika Anda ingin meneruskan lebih dari satu bagian informasi ke aktivitas yang telah dimulai.
  • Jika informasi yang ingin Anda teruskan tidak bisa dinyatakan melalui URI.

Data dan ekstra maksud tidak eksklusif; Anda bisa menggunakan data URI dan ekstra untuk informasi tambahan yang diperlukan aktivitas yang dimulai untuk memproses data dalam URI itu.

Tambahkan data ke maksud

Untuk menambahkan data ke maksud eksplisit dari aktivitas pembuatnya, buat objek maksud seperti yang Anda lakukan sebelumnya:

Intent messageIntent = new Intent(this, ShowMessageActivity.class);

Gunakan metode setData() bersama objek Uri untuk menambahkan URI itu ke maksud. Beberapa contoh penggunaan setData() bersama URI:

// A web page URL
messageIntent.setData(Uri.parse("http://www.google.com"));
// a Sample file URI
messageIntent.setData(Uri.fromFile(new File("/sdcard/sample.jpg")));
// A sample content: URI for your app's data model
messageIntent.setData(Uri.parse("content://mysample.provider/data"));
// Custom URI
messageIntent.setData(Uri.parse("custom:" + dataID + buttonId));

Perlu diingat bahwa bidang data hanya bisa berisi URI tunggal; jika Anda memanggil setData() beberapa kali, hanya nilai terakhir yang akan digunakan. Gunakan ekstra maksud untuk menyertakan informasi tambahan (termasuk URI.)

Setelah menambahkan data, Anda bisa memulai aktivitas dengan maksud seperti biasanya.

startActivity(messageIntent);

Tambahkan ekstra ke maksud

Untuk menambahkan ekstra maksud ke maksud eksplisit dari aktivitas pembuatnya:

  1. Tentukan kunci yang akan digunakan untuk informasi yang ingin dimasukkan ke dalam ekstra, atau definisikan sendiri. Setiap bagian informasi memerlukan kunci unik.
  2. Gunakan metode putExtra() untuk menambahkan pasangan kunci/nilai ke ekstra maksud. Secara opsional Anda bisa membuat objek Bundle, menambahkan data ke bundel, kemudian menambahkan bundel ke maksud.

Kelas Intent menyertakan sejumlah kunci ekstra maksud yang bisa digunakan, didefinisikan sebagai konstanta yang dimulai dengan kata EXTRA_. Misalnya, Anda bisa menggunakan Intent.EXTRA_EMAIL untuk menunjukkan larik alamat email (sebagai string), atau Intent.EXTRA_REFERRER untuk menetapkan informasi tentang aktivitas pembuat yang mengirim maksud tersebut.

Anda juga bisa mendefinisikan kunci ekstra maksud milik sendiri. Secara konvensional Anda mendefinisikan kunci ekstra maksud sebagai variabel-variabel statis dengan nama yang dimulai kata EXTRA_. Untuk menjamin kunci tersebut unik, nilai string kunci itu sendiri harus diawali dengan nama kelas yang benar-benar memenuhi syarat aplikasi. Misalnya:

public final static String EXTRA_MESSAGE = "com.example.mysampleapp.MESSAGE";
public final static String EXTRA_POSITION_X = "com.example.mysampleapp.X";
public final static String EXTRA_POSITION_Y = "com.example.mysampleapp.Y";

Buat objek maksud (jika belum ada):

Intent messageIntent = new Intent(this, ShowMessageActivity.class);

Gunakan metode putExtra() bersama kunci untuk memasukkan data ke dalam ekstra maksud. Kelas Intent mendefinisikan banyak metode putExtra() untuk jenis data yang berbeda:

messageIntent.putExtra(EXTRA_MESSAGE, "this is my message");
messageIntent.putExtra(EXTRA_POSITION_X, 100);
messageIntent.putExtra(EXTRA_POSITION_Y, 500);

Atau, Anda bisa membuat bundel baru dan mengisinya dengan ekstra maksud. Bundel mendefinisikan banyak metode “put” untuk jenis data primitif yang berbeda serta objek yang mengimplementasikan antarmuka Parcelable Android atau Serializable Java.

Bundle extras = new Bundle();
extras.putString(EXTRA_MESSAGE, "this is my message");
extras.putInt(EXTRA_POSITION_X, 100);
extras.putInt(EXTRA_POSITION_Y, 500);

Setelah Anda mengisi bundel tersebut, tambahkan ke maksud dengan metode putExtras() (perhatikan “s” di Extras):

messageIntent.putExtras(extras);

Mulai aktivitas dengan maksud seperti biasa:

startActivity(messageIntent);

Ambil data dari maksud di aktivitas yang dimulai

Bila Anda memulai aktivitas bersama maksud, aktivitas yang telah dimulai akan memiliki akses ke maksud dan data yang dimuatnya.

Untuk mengambil maksud yang digunakan untuk memulai aktivitas (atau komponen lain), gunakan metode getIntent():

Intent intent = getIntent();

Gunakan getData() untuk mendapatkan URI dari maksud itu:

Uri locationUri = getData();

Untuk mendapatkan ekstra dari maksud, Anda perlu mengetahui kunci untuk pasangan kunci/nilai. Anda bisa menggunakan ekstra Intent standar jika telah menggunakannya, atau bisa menggunakan kunci yang didefinisikan di aktivitas pembuatnya (jika didefinisikan sebagai publik.)

Gunakan salah satu metode getExtra() untuk mengekstrak data ekstra dari objek maksud:

String message = intent.getStringExtra(MainActivity.EXTRA_MESSAGE);
int positionX = intent.getIntExtra(MainActivity.EXTRA_POSITION_X);
int positionY = intent.getIntExtra(MainActivity.EXTRA_POSITION_Y);

Atau Anda bisa mendapatkan seluruh bundel ekstra dari maksud dan mengekstrak nilai dengan beragam metode Bundle:

Bundle extras = intent.getExtras();
String message = extras.getString(MainActivity.EXTRA_MESSAGE);

Mendapatkan data kembali dari aktivitas

Bila Anda memulai aktivitas bersama sebuah maksud, aktivitas pembuatnya akan dihentikan sementara, dan aktivitas baru tetap di layar hingga pengguna mengeklik tombol kembali, atau panggil metode finish() di handler klik atau fungsi lainnya yang mengakhiri keterlibatan pengguna pada aktivitas ini.

Kadang-kadang bila mengirim data ke aktivitas bersama sebuah maksud, Anda juga ingin mendapatkan kembali data dari maksud itu. Misalnya, Anda mungkin memulai aktivitas galeri foto yang memungkinkan pengguna memilih foto. Dalam hal ini aktivitas asli Anda perlu menerima informasi tentang foto yang dipilih pengguna dari aktivitas yang diluncurkan.

Untuk meluncurkan aktivitas baru dan mendapatkan kembali hasilnya, lakukan langkah-langkah berikut di aktivitas pembuatnya:

  1. Sebagai ganti meluncurkan aktivitas bersama startActivity(), panggil startActivityForResult() bersama maksud dan kode permintaan.
  2. Buat maksud baru di aktivitas yang diluncurkan dan tambahkan data yang dikembalikan ke maksud itu.
  3. Implementasikan onActivityResult() di aktivitas pembuatnya untuk memproses data yang dikembalikan.

Anda akan mempelajari tentang setiap langkah di bagian berikut ini.

Gunakan startActivityForResult() untuk meluncurkan aktivitas

Untuk mendapatkan kembali data dari aktivitas yang diluncurkan, mulailah aktivitas itu bersama metode startActivityForResult() sebagai ganti startActivity().

startActivityForResult(messageIntent, TEXT_REQUEST);

Metode startActivityForResult(), seperti startActivity(), mengambil argumen maksud yang berisi informasi tentang aktivitas yang diluncurkan dan data yang dikirim ke aktivitas itu. Akan tetapi, metode startActivityForResult() juga memerlukan kode permintaan.

Kode permintaan adalah integer yang mengidentifikasi permintaan dan bisa digunakan untuk membedakan hasil bila Anda memproses data yang dikembalikan. Misalnya, jika meluncurkan satu aktivitas untuk mengambil foto dan aktivitas lain untuk memilih foto dari galeri, Anda akan memerlukan kode permintaan yang berbeda untuk mengidentifikasi permintaan yang menjadi pemilik data yang dikembalikan.

Secara konvensional, Anda mendefinisikan kode permintaan sebagai variabel-variabel integer statis dengan nama yang menyertakan REQUEST. Gunakan integer yang berbeda untuk setiap kode. Misalnya:

public static final int PHOTO_REQUEST = 1;
public static final int PHOTO_PICK_REQUEST = 2;
public static final int TEXT_REQUEST = 3;

Kembalikan respons dari aktivitas yang diluncurkan

Data respons dari aktivitas yang diluncurkan kembali ke aktivitas pembuatnya akan dikirim dalam maksud, baik dalam data maupun ekstra. Anda membentuk maksud yang dikembalikan ini dan memasukkan data ke dalamnya menggunakan cara yang sangat mirip dengan yang Anda lakukan untuk maksud yang mengirimnya. Biasanya aktivitas yang diluncurkan akan memiliki metode onClick atau metode callback masukan pengguna lain yang Anda gunakan untuk memproses aksi pengguna dan menutup aktivitas. Di sini juga Anda membentuk respons.

Untuk mengembalikan data dari aktivitas yang diluncurkan, buat objek maksud kosong yang baru.

Intent returnIntent = new Intent();
Catatan: Untuk menghindari kebingungan atas data yang dikirim dengan data yang dikembalikan, gunakan objek maksud baru, bukan menggunakan kembali objek maksud pengirim asal.

Maksud hasil yang dikembalikan tidak memerlukan kelas atau nama komponen berakhir di tempat yang tepat. Sistem Android akan mengarahkan respons kembali ke aktivitas pembuatnya untuk Anda.

Tambahkan data atau ekstra ke maksud dengan cara sama seperti yang Anda lakukan pada maksud asal. Anda mungkin perlu mendefinisikan kunci untuk ekstra maksud yang dikembalikan pada awal kelas.

public final static String EXTRA_RETURN_MESSAGE =
    "com.example.mysampleapp.RETURN_MESSAGE";

Selanjutnya masukkan data yang dikembalikan ke maksud seperti biasa. Di sini, pesan yang dikembalikan adalah ekstra maksud dengan kunci EXTRA_RETURN_MESSAGE.

messageIntent.putExtra(EXTRA_RETURN_MESSAGE, mMessage);

Gunakan metode setResult() bersama kode respons dan maksud dengan data respons:

setResult(RESULT_OK,replyIntent);

Kode respons didefinisikan oleh kelas Activity, dan bisa berupa

  • RESULT_OK: permintaan berhasil.
  • RESULT_CANCELED: pengguna membatalkan operasi.
  • RESULT_FIRST_USER: untuk mendefinisikan kode hasil milik Anda.

Anda akan menggunakan kode hasil di aktivitas pembuatnya.

Terakhir, panggil finish() untuk menutup aktivitas dan melanjutkan aktivitas pembuatnya:

finish();

Baca data respons di onActivityResult()

Karena sekarang aktivitas yang diluncurkan telah mengirimkan data kembali ke aktivitas pembuatnya bersama maksud, aktivitas pertama itu harus menangani data tersebut. Untuk menangani data yang dikembalikan di aktivitas pembuatnya, implementasikan metode callback onActivityResult(). Inilah sebuah contoh sederhana.

public void onActivityResult(int requestCode, int resultCode,  Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == TEXT_REQUEST) {
        if (resultCode == RESULT_OK) {
            String reply =
                data.getStringExtra(SecondActivity.EXTRA_RETURN_MESSAGE);
                // process data
        }
    }
}

Tiga argumen untuk onActivityResult() berisi semua informasi yang Anda perlukan untuk menangani data yang dikembalikan.

  • Kode permintaan. Kode permintaan yang Anda setel saat meluncurkan aktivitas bersama startActivityForResult(). Jika Anda meluncurkan aktivitas yang berbeda untuk melakukan operasi yang berbeda, gunakan kode ini untuk mengidentifikasi data tertentu yang Anda dapatkan kembali.
  • Kode hasil: kode hasil yang disetel di aktivitas yang diluncurkan, biasanya salah satu dari RESULT_OK atau RESULT_CANCELED.
  • Data maksud. maksud berisi data yang dikembalikan dari aktivitas peluncur.

Metode contoh yang ditampilkan di atas menampilkan logika tipikal untuk menangani kode permintaan dan kode respons. Pengujian pertama adalah untuk permintaan TEXT_REQUEST, dan bahwa hasilnya adalah berhasil. Di dalam isi pengujian itu, ekstrak informasi yang dikembalikan dari maksud. Gunakan getData() untuk mendapatkan data maksud, atau getExtra() untuk mengambil nilai dari ekstra maksud bersama kunci tertentu.

Setiap aplikasi dengan kompleksitas apa pun yang Anda bangun akan menyertakan beberapa aktivitas, baik yang didesain dan diimplementasikan oleh Anda, maupun yang berpotensi di aplikasi lain. Karena pengguna Anda berpindah-pindah dalam aplikasi dan di antara aktivitas, navigasi yang konsisten menjadi semakin penting untuk pengalaman pengguna aplikasi. Beberapa hal lebih mengganggu pengguna daripada navigasi dasar yang berperilaku tidak konsisten dan tak terduga. Mendesain navigasi aplikasi Anda dengan bijak akan membuat penggunaan aplikasi tersebut bisa diprediksi dan bisa diandalkan pengguna.

Sistem Android mendukung dua bentuk strategi navigasi yang berbeda untuk aplikasi Anda.

  • Navigasi Sementara atau Kembali, yang disediakan melalui tombol kembali di perangkat, dan back-stack.
  • Navigasi leluhur, atau Naik, yang disediakan oleh Anda sebagai opsi di bilah aksi aplikasi.

Navigasi Kembali memungkinkan pengguna Anda untuk kembali ke aktivitas sebelumnya dengan mengetuk tombol kembali di perangkat Tombol kembali di perangkat . Navigasi kembali juga disebut navigasi sementara karena tombol kembali menyusuri riwayat layar yang baru saja ditampilkan, dalam urutan kronologi terbalik.

Back-stack adalah serangkaian aktivitas yang telah dikunjungi pengguna dan bisa dikunjungi kembali oleh pengguna dengan tombol kembali. Setiap kali aktivitas baru dimulai, aktivitas akan didorong ke back-stack dan mengambil fokus pengguna. Aktivitas sebelumnya akan dihentikan, namun tetap tersedia di back-stack. Back-stack beroperasi berdasarkan mekanisme “masuk terakhir, keluar pertama”, jadi bila pengguna selesai dengan aktivitas saat ini dan menekan tombol Kembali, aktivitas tersebut akan dimunculkan dari tumpukan (serta dimusnahkan) dan aktivitas sebelumnya dilanjutkan.

Karena aplikasi bisa memulai aktivitas baik di dalam maupun di luar satu aplikasi, back-stack berisi semua aktivitas yang telah diluncurkan oleh pengguna dalam urutan terbalik. Setiap kali pengguna menekan tombol Kembali, setiap aktivitas di tumpukan akan dimunculkan untuk membuka aktivitas sebelumnya, hingga pengguna kembali ke layar Utama.Back-stack aktivitas

Android menyediakan back-stack untuk setiap tugas. Tugas adalah konsep penyusunan semua aktivitas yang berinteraksi dengan pengguna saat melakukan operasi, baik di dalam aplikasi maupun di beberapa aplikasi. Sebagian besar tugas dimulai dari layar utama Android, dan mengetuk ikon aplikasi akan memulai tugas (serta back-stack baru) untuk aplikasi itu. Jika pengguna menggunakan aplikasi sebentar, mengetuk beranda, dan memulai aplikasi, aplikasi baru itu akan diluncurkan di tugasnya sendiri dan memiliki back-stack sendiri. Jika pengguna kembali ke aplikasi pertama, back-stack tugas pertama akan kembali. Menyusuri dengan tombol kembali hanya akan mengembalikan ke aktivitas di tugas saat ini, bukan untuk semua tugas yang berjalan pada perangkat. Android memungkinkan pengguna menyusuri berbagai tugas bersama ringkasan atau layar tugas saat ini, yang bisa diakses dengan tombol segi empat di sudut kanan bawah perangkat Tombol tugas perangkat .Layar Tugas Saat Ini

Dalam sebagian besar kasus, Anda tidak perlu khawatir tentang pengelolaan tugas atau back-stack untuk aplikasi—sistem terus melacak hal ini untuk Anda, dan tombol kembali selalu tersedia pada perangkat.

Akan tetapi, mungkin ada saatnya Anda ingin mengganti perilaku default untuk tugas atau untuk back-stack. Misalnya, jika layar Anda berisi browser web yang disematkan yang memungkinkan pengguna menyusuri laman web, Anda mungkin ingin menggunakan perilaku kembali default di browser bila pengguna menekan tombol Kembali di perangkat, daripada mengembalikan ke aktivitas sebelumnya. Anda mungkin juga perlu mengubah perilaku default aplikasi dalam kasus khusus lainnya seperti pada notifikasi atau widget, sehingga aktivitas yang berada jauh di dalam aplikasi Anda mungkin diluncurkan sebagai tugasnya sendiri, tanpa back-stack sama sekali. Anda akan mengetahui selengkapnya tentang pengelolaan tugas dan back-stack di bagian berikutnya.

Navigasi naik, kadang-kadang disebut sebagai navigasi leluhur atau logis, digunakan untuk navigasi dalam aplikasi berdasarkan hubungan hierarki eksplisit di antara layar. Dengan navigasi naik, aktivitas Anda disusun dalam suatu hierarki, dan aktivitas “anak” menampilkan panah hadap-kiri di bilah aksi Tombol naik (di bilah aksi)  yang mengembalikan pengguna ke aktivitas “induk”. Aktivitas teratas di hierarki biasanya adalah aktivitas utama Anda, dan pengguna tidak bisa naik lagi dari sana.Navigasi Naik

Misalnya, jika aktivitas utama di aplikasi email adalah daftar semua pesan, memilih sebuah pesan akan meluncurkan aktivitas kedua untuk menampilkan satu email itu. Dalam hal ini, aktivitas pesan akan menyediakan tombol Naik yang mengembalikan ke daftar pesan.

Perilaku tombol Naik didefinisikan oleh Anda di setiap aktivitas berdasarkan cara mendesain navigasi aplikasi. Dalam banyak kasus, navigasi Naik dan Kembali mungkin menyediakan perilaku yang sama: cuma mengembalikan ke aktivitas sebelumnya. Misalnya, aktivitas Setelan mungkin tersedia dari aktivitas apa pun di aplikasi Anda, sehingga “naik” sama dengan kembali — cuma mengembalikan pengguna ke tempat sebelumnya di hierarki.

Menyediakan perilaku Naik untuk aplikasi Anda adalah hal yang opsional, namun praktik desain yang baik, adalah menyediakan navigasi yang konsisten untuk berbagai aktivitas di aplikasi Anda.

Implementasikan navigasi naik bersama aktivitas induk

Dengan proyek template standar di Android Studio, mudah untuk mengimplementasikan navigasi Naik. Jika satu aktivitas adalah anak aktivitas lain di hierarki aktivitas aplikasi, tetapkan induk aktivitas itu di Manifes Android.

Mulai di Android 4.1 (API level 16), deklarasikan induk logis setiap aktivitas dengan menetapkan atribut android:parentActivityName di elemen <activity> . Untuk mendukung Android versi lama, sertakan informasi <meta-data> untuk mendefinisikan aktivitas induk secara eksplisit. Gunakan kedua metode agar kompatibel mundur dengan semua versi Android.

Inilah definisi kerangka untuk kedua aktivitas utama (induk) dan aktivitas kedua (anak):

<application ... >
    <!-- The main/home activity (it has no parent activity) -->
         <activity
        android:name=".MainActivity" ...>
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>

    </activity>
    <!-- A child of the main activity -->
    <activity android:name=".SecondActivity"
        android:label="@string/activity2_name"
        android:parentActivityName=".MainActivity">
        <meta-data
            android:name="android.support.PARENT_ACTIVITY"
            android:value="com.example.android.twoactivities.MainActivity" />
    </activity> 
</application>

 

2.2: Daur Hidup Aktivitas dan Mengelola Keadaan

 

Dalam bab ini, Anda akan mempelajari tentang daur hidup aktivitas, kejadian callback yang bisa Anda implementasikan untuk melakukan tugas di setiap tahap daur hidup, dan cara menangani keadaan instance aktivitas di seluruh daur hidup aktivitas.

Tentang daur hidup aktivitas

Daur hidup aktivitas adalah serangkaian keadaan aktivitas yang terjadi selama masa pakai keseluruhan, dari pertama kali dibuat hingga ketika dimusnahkan dan sistem mengklaim kembali sumber daya aktivitas tersebut. Karena pengguna berinteraksi dengan aplikasi Anda dan aplikasi lain pada perangkat, aktivitas yang berbeda akan beralih ke keadaan yang berbeda.

Misalnya, bila Anda memulai aplikasi, aktivitas utama aplikasi (Aktivitas 1) akan dimulai, muncul ke latar depan, dan menerima fokus pengguna. Bila Anda memulai aktivitas kedua (Aktivitas 2), aktivitas baru tersebut juga akan dibuat dan dimulai, dan aktivitas utama akan dihentikan. Bila Anda selesai dengan aktivitas kedua dan mengarah kembali, aktivitas utama akan dilanjutkan. Aktivitas kedua berhenti dan tidak lagi diperlukan; jika pengguna tidak melanjutkan aktivitas kedua, aktivitas akhirnya akan dimusnahkan oleh sistem.Daur Hidup Aktivitas

Keadaan aktivitas dan metode callback daur hidup

Bila aktivitas bertransisi masuk dan keluar dari keadaan daur hidup berbeda saat berjalan, sistem Android akan memanggil sejumlah metode callback daur hidup pada setiap tahap. Semua metode callback adalah kaitan yang bisa Anda ganti di setiap kelas Activity untuk mendefinisikan perilaku aktivitas bila pengguna meninggalkan dan memasuki aktivitas kembali. Perlu diingat bahwa keadaan daur hidup (dan callback) adalah per aktivitas, bukan per aplikasi, dan Anda bisa mengimplementasikan perilaku berbeda di titik yang berbeda dalam daur hidup aktivitas yang berbeda di aplikasi.

Gambar ini menampilkan setiap keadaan aktivitas dan metode callback yang terjadi saat transisi aktivitas di antara keadaan yang berbeda:Diagram Daur Hidup Aplikasi

Bergantung pada kompleksitas aktivitas, mungkin tidak semua metode callback daur hidup diimplementasikan di aktivitas. Akan tetapi, Anda perlu memahami satu per satu dan mengimplementasikan metode tersebut untuk memastikan aplikasi berperilaku seperti harapan pengguna. Mengelola daur hidup aktivitas Anda dengan mengimplementasikan metode callback sangat penting untuk mengembangkan aplikasi yang kuat dan fleksibel.

Aktivitas Dibuat (metode onCreate())

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // The activity is being created.
}

Aktivitas Anda masuk ke keadaan yang dibuat bila dimulai untuk pertama kali. Bila aktivitas dibuat pertama kali, sistem akan memanggil metode onCreate() untuk melakukan inisialisasi aktivitas itu. Misalnya, bila pengguna mengetuk ikon aplikasi dari layar utama atau beranda untuk memulai aplikasi itu, sistem akan memanggil metode onCreate() untuk aktivitas dalam aplikasi yang Anda deklarasikan sebagai aktivitas “peluncur” atau “utama”. Dalam hal ini metode onCreate() aktivitas utama analog dengan metode main() di program lainnya.

Demikian juga, jika aplikasi Anda memulai aktivitas lain dengan maksud (baik eksplisit maupun implisit), sistem akan mencocokkan permintaan maksud dengan aktivitas dan memanggil onCreate() untuk aktivitas baru itu.

Metode onCreate() adalah satu-satunya callback yang harus Anda implementasikan di kelas aktivitas. Di metode onCreate(), Anda menjalankan logika startup aplikasi dasar yang hanya boleh terjadi sekali, seperti mempersiapkan antarmuka pengguna, menetapkan variabel-variabel cakupan kelas, atau mempersiapkan tugas latar belakang.

Dibuat adalah keadaan sementara; aktivitas tetap berada dalam keadaan dibuat hanya selama dibutuhkan untuk menjalankan onCreate(), kemudian aktivitas beralih ke keadaan dimulai.

Aktivitas Dimulai (metode onStart())

@Override
protected void onStart() {
    super.onStart();
    // The activity is about to become visible.
}

Setelah aktivitas Anda diinisialisasi dengan onCreate(), sistem akan memanggil metode onStart(), dan aktivitas berada dalam keadaan dimulai. Metode onStart() juga dipanggil jika aktivitas yang dihentikan kembali ke latar depan, seperti bila pengguna mengeklik tombol kembali atau naik untuk mengarah ke layar sebelumnya. Meskipun OnCreate() hanya dipanggil sekali bila aktivitas dibuat, metode onStart() bisa digunakan berkali-kali selama daur hidup aktivitas saat pengguna menyusuri aplikasi Anda.

Bila aktivitas berada dalam keadaan dimulai dan terlihat di layar, pengguna tidak bisa berinteraksi dengan aktivitas tersebut hingga onResume() dipanggil, aktivitas berjalan, dan aktivitas berada di latar depan.

Biasanya Anda mengimplementasikan onStart() di aktivitas sebagai pasangan untuk metode OnStop(). Misalnya, jika Anda melepas sumber daya perangkat keras (seperti GPS atau sensor) bila aktivitas dihentikan, Anda bisa mendaftarkan ulang sumber daya tersebut di metode onStart().

Dimulai, seperti halnya dibuat, adalah keadaan sementara. Setelah memulai, aktivitas berpindah ke keadaan dilanjutkan (berjalan).

Aktivitas dilanjutkan/berjalan (metode onResume())

@Override
protected void onResume() {
    super.onResume();
    // The activity has become visible (it is now "resumed").
}

Aktivitas Anda berada dalam keadaan dilanjutkan saat diinisialisasi, terlihat pada layar, dan siap digunakan. Keadaan dilanjutkan biasanya disebut keadaan berjalan, karena dalam keadaan ini pengguna benar-benar berinteraksi dengan aplikasi Anda.

Saat pertama aktivitas dimulai, sistem akan memanggil metode onResume() persis setelah onStart(). Metode onResume() juga mungkin dipanggil beberapa kali, setiap kali aplikasi kembali dari keadaan dihentikan sementara.

Sebagaimana dengan metode onStart() dan OnStop(), yang diimplementasikan berpasangan, Anda biasanya hanya mengimplementasikan onResume() sebagai pasangan untuk onPause(). Misalnya, jika dalam metode onPause() Anda menghentikan setiap animasi pada layar, Anda akan memulai lagi animasi tersebut di onResume().

Aktivitas ini tetap berada dalam keadaan dilanjutkan selama aktivitas berada di latar depan dan pengguna berinteraksi dengannya. Dari keadaan dilanjutkan, aktivitas bisa beralih ke keadaan dihentikan sementara.

Aktivitas dihentikan sementara (metode onPause())

@Override
protected void onPause() {
    super.onPause();
    // Another activity is taking focus
    // (this activity is about to be "paused").
}

Keadaan dihentikan sementara bisa terjadi dalam sejumlah situasi:

  • Aktivitas akan masuk ke latar belakang, namun belum sepenuhnya berhenti. Ini merupakan indikasi pertama bahwa pengguna meninggalkan aktivitas Anda.
  • Aktivitas hanya terlihat sebagian di layar, karena dialog atau aktivitas transparan lainnya dihamparkan di atasnya.
  • Dalam mode multi-jendela atau layar terpisah (API 24), aktivitas ini ditampilkan pada layar, namun beberapa aktivitas lain memiliki fokus pengguna.

Sistem memanggil metode onPause() bila aktivitas beralih ke keadaan dihentikan sementara. Karena metode onPause() adalah indikasi pertama yang didapat bahwa pengguna mungkin meninggalkan aktivitas, Anda bisa menggunakan onPause() untuk menghentikan pemutaran animasi atau video, melepas sumber daya yang mengandalkan perangkat keras, atau mengikat perubahan aktivitas yang belum disimpan (seperti draf email).

Metode onPause() akan segera dijalankan. Jangan menggunakan onPause() untuk operasi yang banyak menggunakan CPU seperti menulis data persisten ke database. Aplikasi mungkin masih terlihat di layar saat diteruskan ke keadaan dihentikan sementara, dan penundaan apa pun dalam eksekusi onPause() bisa memperlambat transisi pengguna ke aktivitas berikutnya. Implementasikan operasi beban-berat bila aplikasi berada dalam keadaan dihentikan.

Perhatikan, dalam mode multi-jendela (API 24), aktivitas yang dihentikan sementara masih bisa terlihat pada layar. Dalam hal ini, Anda tidak perlu menghentikan sementara pemutaran animasi atau video seperti yang diinginkan untuk aktivitas yang terlihat sebagian. Anda bisa menggunakan metode inMultiWindowMode() di kelas Activity untuk menguji apakah aplikasi sedang berjalan dalam mode multi-jendela.

Aktivitas Anda bisa berpindah dari keadaan dihentikan sementara ke keadaan dilanjutkan (jika pengguna kembali ke aktivitas tersebut) atau ke keadaan dihentikan (jika pengguna meninggalkan aktivitas secara bersamaan).

Aktivitas dihentikan (metode onStop())

@Override
protected void onStop() {
    super.onStop();
    // The activity is no longer visible (it is now "stopped")
}

Aktivitas berada dalam keadaan dihentikan bila tidak lagi terlihat pada layar. Hal ini biasanya karena pengguna memulai aktivitas lain, atau kembali ke layar utama. Sistem mempertahankan instance aktivitas di back-stack, dan jika pengguna kembali ke aktivitas tersebut, maka akan dimulai lagi. Aktivitas yang dihentikan mungkin dimatikan secara bersamaan oleh sistem Android jika sumber daya minim.

Sistem akan memanggil metode onStop() bila aktivitas berhenti. Implementasikan metode OnStop() untuk menyimpan data persisten dan melepas sisa sumber daya yang belum dirilis di onPause(), termasuk operasi yang mungkin terlalu berat untuk onPause().

Aktivitas dimusnahkan (metode onDestroy())

@Override
protected void onDestroy() {
    super.onDestroy();
    // The activity is about to be destroyed.
}

Bila dimusnahkan, aktivitas akan dimatikan sepenuhnya, dan instance Aktivitas diklaim ulang oleh sistem. Hal ini bisa terjadi dalam sejumlah kasus:

  • Anda memanggil finish() di aktivitas untuk mematikannya secara manual.
  • Pengguna kembali ke aktivitas sebelumnya.
  • Perangkat dalam situasi minim memori sehingga sistem mengklaim kembali aktivitas yang dihentikan untuk membebaskan lebih banyak sumber daya.
  • Terjadi perubahan konfigurasi perangkat. Anda akan mengetahui selengkapnya tentang perubahan konfigurasi nanti dalam bab ini.

Gunakan onDestroy() untuk menghapus sepenuhnya setelah aktivitas Anda sehingga tidak ada komponen (seperti thread) yang berjalan setelah aktivitas ini dimusnahkan.

Perhatikan, ada kalanya sistem akan benar-benar mematikan proses hosting aktivitas tanpa memanggil metode ini (atau metode lainnya), sehingga Anda tidak boleh mengandalkan onDestroy() untuk menyimpan data atau keadaan aktivitas yang diperlukan. Sebagai gantinya, gunakan onPause() atau onStop().

Aktivitas dimulai kembali (metode onRestart())

@Override
protected void onRestart() {
    super.onRestart();
    // The activity is about to be restarted.
}

Keadaan dimulai kembali adalah keadaan sementara yang hanya terjadi jika aktivitas yang dihentikan dimulai kembali. Jika metode onRestart() dipanggil di antara onStop() dan onStart(). Jika memiliki sumber daya yang perlu dihentikan atau dimulai, Anda biasanya mengimplementasikan perilaku tersebut di OnStop() atau onStart(), bukan onRestart().

Perubahan konfigurasi dan keadaan aktivitas

Sebelumnya di bagian onDestroy() Anda telah mengetahui bahwa aktivitas mungkin dimusnahkan bila pengguna mengarah kembali, oleh Anda dengan metode finish(), atau oleh sistem bila perlu membebaskan sumber daya. Aktivitas Anda dimusnahkan keempat kalinya bila perangkat mengalami perubahan konfigurasi.

Perubahan konfigurasi terjadi di perangkat, dalam waktu proses, dan membatalkan validasi layout saat ini atau sumber daya lainnya di aktivitas Anda Bentuk yang paling umum dari perubahan konfigurasi adalah bila perangkat diputar. Bila perangkat diputar dari potret ke lanskap, atau sebaliknya, layout aplikasi Anda juga perlu diubah. Sistem membuat ulang aktivitas untuk membantu aktivitas tersebut beradaptasi dengan konfigurasi baru dengan memuat sumber daya alternatif (seperti layout khusus lanskap).

Perubahan konfigurasi lainnya bisa meliputi perubahan di lokal (pengguna memilih bahasa sistem yang berbeda), atau pengguna masuk ke mode multi-jendela (Android 7). Dalam mode multi-jendela, jika Anda telah mengonfigurasi aplikasi agar bisa diubah ukurannya, Android akan membuat ulang aktivitas tersebut untuk menggunakan definisi layout bagi ukuran aktivitas baru yang lebih kecil.

Bila terjadi perubahan konfigurasi, sistem Android akan menutup aktivitas Anda (memanggil onPause(), OnStop(), dan onDestroy()), kemudian memulainya dari awal (memanggil onCreate(), onStart(), dan onResume()).

Keadaan instance aktivitas

Bila aktivitas dimusnahkan dan dibuat ulang, ada implikasi untuk keadaan waktu proses aktivitas itu. Bila aktivitas dihentikan sementara atau dihentikan sepenuhnya, keadaan aktivitas akan dipertahankan karena aktivitas tersebut masih ditahan dalam memori. Bila aktivitas dibuat ulang, keadaan aktivitas dan kemajuan pengguna di aktivitas tersebut akan hilang, dengan pengecualian ini:

  • Sebagian informasi keadaan aktivitas secara otomatis disimpan secara default. Keadaan tampilan di layout Anda dengan ID unik (seperti yang didefinisikan oleh atribut android:id di layout) disimpan dan dipulihkan bila aktivitas dibuat ulang. Dalam hal ini, nilai-nilai yang dimasukkan pengguna di tampilan EditText biasanya dipertahankan bila aktivitas tersebut dibuat ulang.
  • Maksud yang digunakan untuk memulai aktivitas, dan informasi yang tersimpan di data atau ekstra maksud, tetap tersedia untuk aktivitas itu bila dibuat ulang.

Keadaan aktivitas disimpan sebagai rangkaian pasangan kunci/nilai di objek Bundle yang disebut keadaan instance aktivitas. Sistem akan menyimpan informasi keadaan default ke bundel keadaan instance tepat sebelum aktivitas dihentikan, dan meneruskan bundel itu ke instance aktivitas baru untuk dipulihkan.

Anda bisa menambahkan data instance sendiri ke bundel keadaan instance dengan mengganti callback onSaveInstanceState(). Bundel keadaan diteruskan ke metode onCreate(), sehingga Anda bisa memulihkan data keadaan instance tersebut bila aktivitas dibuat. Ada juga callback onRestoreInstanceState() yang bisa Anda gunakan untuk memulihkan data keadaan.

Karena rotasi perangkat adalah kasus penggunaan umum untuk aplikasi, pastikan Anda menguji bahwa aktivitas berperilaku dengan benar sebagai respons terhadap perubahan konfigurasi ini, dan implementasikan instance keadaan jika diperlukan.

Catatan:Keadaan instance aktivitas bersifat khusus untuk intance aktivitas tertentu, yang berjalan di satu tugas. Jika pengguna menghentikan aplikasi secara paksa, maka boot ulang perangkat, atau jika sistem Android menutup seluruh proses aplikasi untuk menjaga memori, keadaan instance aktivitas akan hilang. Untuk mempertahankan perubahan keadaan di seluruh instance aplikasi dan mem-boot ulang perangkat, Anda perlu menulis data itu ke preferensi bersama. Anda akan mengetahui selengkapnya tentang preferensi bersama dalam bab berikutnya.

Menyimpan keadaan instance aktivitas

Untuk menyimpan informasi ke bundel keadaan instance, gunakan callback onSaveInstanceState(). Ini bukan metode callback daur hidup, namun metode ini dipanggil bila pengguna meninggalkan aktivitas Anda (kadang-kadang sebelum metode OnStop()).

@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    super.onSaveInstanceState(savedInstanceState);
    // save your state data to the instance state bundle
}

Di metode onSaveInstanceState() diteruskan objek Bundle (kumpulan pasangan kunci/nilai) bila dipanggil. Ini adalah bundel keadaan instance yang nanti Anda tambahkan informasi keadaan aktivitas sendiri.

Anda telah mempelajari tentang berbagai bundel di bab sebelumnya saat menambahkan kunci dan nilai untuk ekstra maksud. Tambahkan informasi ke bundel keadaan instance dengan cara yang sama, dengan kunci yang Anda definisikan dan beragam metode “put” yang didefinisikan dalam kelas Bundle:

@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    super.onSaveInstanceState(savedInstanceState);

    // Save the user's current game state
    savedInstanceState.putInt("score", mCurrentScore);
    savedInstanceState.putInt("level", mCurrentLevel);
}

Jangan lupa memanggil melalui kelas super, untuk memastikan keadaan hierarki tampilan juga disimpan ke bundel.

Memulihkan keadaan instance aktivitas

Setelah menyimpan keadaan instance aktivitas, Anda juga perlu memulihkannya bila aktivitas tersebut dibuat ulang. Anda bisa melakukannya di salah satu dari dua tempat:

  • Metode callback onCreate(), yang dipanggil bersama bundel keadaan instance bila aktivitas dibuat.
  • Callback onRestoreInstanceState(), yang dipanggil setelah onStart(), setelah aktivitas dibuat.

Sering kali, tempat yang lebih baik untuk memulihkan keadaan aktivitas adalah di onCreate(), untuk memastikan antarmuka pengguna Anda yang menyertakan keadaan tersedia sesegera mungkin.

Untuk memulihkan keadaan instance yang disimpan di onCreate(), uji keberadaan bundel keadaan sebelum Anda mencoba mendapatkan datanya. Bila aktivitas Anda dimulai untuk pertama kali, keadaan tidak akan ada dan bundel akan nol.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); // Always call the superclass first

    // Check whether we're recreating a previously destroyed instance
    if (savedInstanceState != null) {
        // Restore value of members from saved state
        mCurrentScore = savedInstanceState.getInt("score");
        mCurrentLevel = savedInstanceState.getInt("level");
    } else {
        // Probably initialize members with default values for a new instance
    }
    ...
}

 

2.3: Aktivitas dan Maksud Implisit

 

Di bab sebelumnya, Anda telah mempelajari tentang maksud, dan cara meluncurkan aktivitas khusus di aplikasi dengan maksud eksplisit. Di bab ini, Anda akan mempelajari cara mengirim dan menerima maksud implisit, tempat mendeklarasikan aksi umum yang dilakukan dalam maksud, dan sistem akan mencocokkan permintaan dengan aktivitas khusus. Selain itu, Anda akan mengetahui selengkapnya tentang tugas Android, dan cara mengonfigurasi aplikasi untuk mengaitkan aktivitas baru dengan tugas berbeda.

Tentang maksud implisit

Di bab awal, Anda telah mempelajari tentang maksud eksplisit, tempat Anda bisa memulai satu aktivitas dari aktivitas lain dengan menetapkan nama kelas aktivitas itu. Inilah cara paling dasar untuk menggunakan maksud, untuk memulai aktivitas atau komponen aplikasi lainnya dan meneruskan data ke maksud (dan kadang-kadang meneruskan data kembali).

Penggunaan maksud yang lebih fleksibel adalah maksud implisit. Dengan maksud implisit, Anda tidak menetapkan aktivitas yang tepat (atau komponen lainnya) untuk dijalankan—sebagai gantinya, Anda menyertakan informasi secukupnya dalam maksud tentang tugas yang ingin dilakukan. Sistem Android akan mencocokkan informasi dalam maksud permintaan dengan aktivitas yang tersedia di perangkat yang bisa melakukan tugas itu. Jika hanya ada satu aktivitas yang cocok, aktivitas itu akan diluncurkan. Jika ada beberapa aktivitas yang cocok, pengguna disediakan pemilih aplikasi yang memungkinkan mereka memilih aplikasi yang disukai untuk melakukan tugas.Permintaan maksud cocok dengan aplikasi

Misalnya, Anda memiliki aplikasi yang mencantumkan cuplikan video yang tersedia. Jika pengguna menyentuh item dalam daftar, Anda akan memutar cuplikan video itu. Daripada mengimplementasikan keseluruhan pemutar video di aplikasi, Anda bisa meluncurkan maksud yang menetapkan tugas seperti “putar objek video tipe.” Sistem Android selanjutnya akan mencocokkan permintaan dengan aktivitas yang telah mendaftarkan dirinya sendiri untuk memutar objek video tipe.

Aktivitas mendaftarkan dirinya sendiri secara otomatis pada sistem agar dapat menangani maksud implisit dengan filter maksud, yang dideklarasikan dalam manifes Android. Misalnya, aktivitas utama (dan satu-satunya aktivitas utama) untuk aplikasi Anda memiliki filter maksud yang mendeklarasikan aktivitas utama untuk kategori peluncur. Filter maksud ini adalah cara sistem Android mengetahui cara memulai aktivitas tertentu di aplikasi Anda bila pengguna mengetuk ikon untuk aplikasi di layar utama perangkat.

Aksi maksud, kategori, dan data

Maksud implisit, seperti maksud eksplisit, merupakan instance kelas Intent. Selain bagian maksud yang telah Anda pelajari di bab awal (seperti data maksud dan ekstra maksud), bidang-bidang ini digunakan oleh maksud implisit:

  • Aksi maksud, merupakan aksi umum yang harus dilakukan aktivitas penerima. Aksi maksud yang tersedia didefinisikan sebagai konstanta dalam kelas Intent dan dimulai dengan kata ACTION_. Aksi maksud umum adalah ACTION_VIEW, yang Anda gunakan bila memiliki beberapa informasi yang bisa ditampilkan aktivitas kepada pengguna, seperti foto untuk ditampilkan di aplikasi galeri, atau alamat untuk ditampilkan di aplikasi peta. Anda bisa menetapkan aksi untuk sebuah maksud di konstruktor maksud, atau dengan metode setAction().
  • Kategori maksud, menyediakan informasi tambahan tentang kategori komponen yang harus menangani maksud. Kategori maksud bersifat opsional, dan Anda bisa menambahkan lebih dari satu kategori ke maksud. Kategori maksud juga didefinisikan sebagai konstanta di kelas Intent dan dimulai dengan kata CATEGORY_. Anda bisa menambahkan kategori ke maksud dengan metode addCategory().
  • Tipe data, yang menunjukkan MIME tipe data yang digunakan untuk mengoperasikan aktivitas. Biasanya, ini diambil dari URI dalam bidang data maksud, namun Anda juga bisa secara eksplisit mendefinisikan tipe data dengan metode setType().

Tindakan, kategori, dan tipe data maksud keduanya digunakan oleh objek Maksud yang Anda buat di aktivitas pengiriman, serta di filter maksud yang didefinisikan di manifes Android untuk aktivitas penerimaan. Sistem Android menggunakan informasi ini untuk mencocokkan permintaan maksud implisit dengan aktivitas atau komponen lain yang bisa menangani maksud itu.

Mengirim maksud implisit

Memulai aktivitas bersama maksud implisit, dan meneruskan data di antara aktivitas itu, cara kerjanya sangat mirip dengan yang dilakukan untuk maksud eksplisit:

  1. Di aktivitas pengirim, buat objek Maksud baru.
  2. Tambahkan informasi tentang permintaan ke objek Intent, seperti data atau ekstra.
  3. Kirim maksud bersama startActivity() (untuk memulai aktivitas saja) atau startActivityforResult() (untuk memulai aktivitas dan mengharapkan hasil kembali).

Bila membuat objek Intent implisit, Anda:

  • Jangan menetapkan aktivitas khusus atau komponen lain untuk diluncurkan.
  • Menambahkan aksi maksud atau kategori maksud (atau keduanya).
  • Cocokkan maksud dengan sistem sebelum memanggil startActivity() atau startActivityforResult().
  • Menampilkan pemilih aplikasi untuk permintaan (opsional).

Buat objek Intent implisit

Untuk menggunakan maksud implisit, buat objek Intent seperti yang dilakukan untuk maksud eksplisit, hanya tanpa nama komponen spesifik.

Intent sendIntent = new Intent();

Anda juga bisa membuat objek Intent dengan aksi tertentu:

Intent sendIntent = new Intent(Intent.ACTION_VIEW);

Setelah memiliki objek Intent, Anda bisa menambahkan informasi lain (kategori, data, ekstra) dengan beragam metode Intent. Misalnya, kode ini membuat objek Intent implisit, menyetel aksi maksud ke ACTION_SEND, mendefinisikan ekstra maksud untuk menampung teks, dan menyetel tipe data ke tipe MIME “text/plain”.

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
sendIntent.setType("text/plain");

Cocokkan aktivitas sebelumnya memulainya

Bila Anda mendefinisikan maksud implisit dengan aksi dan/atau kategori tertentu, ada kemungkinan bahwa tidak akan ada aktivitas apa pun di perangkat yang bisa menangani permintaan Anda. Jika Anda hanya mengirim maksud dan tidak ada kecocokan, aplikasi akan mogok.

Untuk memverifikasi apakah aktivitas atau komponen lain tersedia untuk menerima maksud Anda, gunakan metode resolveActivity() bersama pengelola paket sistem seperti ini:

if (sendIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(chooser);
}

Jika hasil resolveActivity() bukan nol, maka setidaknya ada satu aplikasi yang tersedia yang bisa menangani maksud, dan aman untuk menggunakan startActivity(). Jangan mengirim maksud jika hasilnya nol.

Jika Anda memiliki fitur yang bergantung pada aktivitas eksternal yang mungkin atau mungkin tidak tersedia di perangkat, praktik terbaik adalah menguji ketersediaan aktivitas eksternal sebelum pengguna mencoba menggunakannya. Jika tidak ada aktivitas yang bisa menangani permintaan Anda (yakni, resolveActivity() mengembalikan nol), nonaktifkan fitur atau sediakan pesan kesalahan untuk fitur tersebut kepada pengguna.

Tampilkan pemilih aplikasi

Untuk menemukan aktivitas atau komponen lain yang bisa menangani permintaan maksud Anda, sistem Android akan mencocokkan maksud implisit dengan aktivitas yang filter maksudnya menunjukkannya bisa melakukan aksi tersebut. Jika beberapa aplikasi yang telah dipasang memang cocok, pengguna akan disajikan pemilih aplikasi yang memungkinkan mereka memilih aplikasi yang ingin digunakan untuk menangani maksud tersebut.Pemilih Aplikasi Android

Dalam banyak kasus, pengguna memiliki aplikasi pilihan untuk tugas yang diberikan, dan mereka akan memilih opsi untuk selalu menggunakan aplikasi itu bagi tugas tersebut. Akan tetapi, jika beberapa aplikasi bisa merespons maksud dan pengguna setiap kali mungkin ingin menggunakan aplikasi yang berbeda, Anda bisa memilih untuk secara eksplisit menampilkan dialog pemilih kapan saja. Misalnya, bila aplikasi melakukan aksi “bagikan ini” bersama aksi ACTION_SEND, pengguna mungkin ingin berbagi menggunakan aplikasi yang berbeda, bergantung pada situasi saat ini.

Untuk menampilkan pemilih, buat maksud wrapper untuk maksud implisit dengan metode createChooser(), kemudian cocokkan dan gunakan startActivity() dengan maksud wrapper. Metode createChooser() juga memerlukan argumen string untuk judul yang muncul pada pemilih. Anda bisa menetapkan judul bersama sumber daya string seperti yang dilakukan pada string lain.

Misalnya:

// The implicit Intent object
Intent sendIntent = new Intent(Intent.ACTION_SEND);
// Always use string resources for UI text.
String title = getResources().getString(R.string.chooser_title);
// Create the wrapper intent to show the chooser dialog.
Intent chooser = Intent.createChooser(sendIntent, title);
// Resolve the intent before starting the activity
if (sendIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(chooser);
}

Menerima maksud implisit

Jika ingin aktivitas di aplikasi merespons maksud implisit (dari aplikasi milik Anda atau aplikasi lain), deklarasikan satu atau beberapa filter maksud di manifes Android. Setiap filter maksud menetapkan tipe maksud yang diterimanya berdasarkan aksi, data, dan kategori maksud. Sistem akan mengirimkan maksud implisit ke komponen aplikasi Anda hanya jika maksud itu bisa melewati salah satu filter maksud.

Catatan:Maksud eksplisit selalu dikirimkan ke targetnya, terlepas dari filter maksud yang dideklarasikan komponen. Sebaliknya, jika aktivitas tidak mendeklarasikan filter maksud apa pun, aktivitas hanya bisa diluncurkan dengan maksud eksplisit.

Setelah aktivitas berhasil diluncurkan bersama maksud implisit, Anda bisa menangani maksud tersebut dan datanya dengan cara sama yang dilakukan pada maksud eksplisit:

  1. Mendapatkan objek Intent dengan getIntent().
  2. Mendapatkan data maksud atau ekstra dari maksud itu.
  3. Melakukan tugas yang diminta maksud.
  4. Mengembalikan data ke aktivitas pemanggil bersama maksud lain, jika diperlukan.

Filter maksud

Definisikan filter maksud dengan satu atau beberapa elemen <intent-filter> di file manifes aplikasi, yang disarangkan di elemen <activity> yang sesuai. Di dalam <intent-filter>, tetapkan tipe maksud yang bisa ditangani aktivitas Anda. Sistem Android mencocokkan maksud implisit dengan aktivitas atau komponen aplikasi lain hanya jika bidang-bidang dalam objek Intent cocok dengan filter maksud untuk komponen itu.

Filter maksud dapat berisi elemen ini, sesuai dengan bidang di objek Intent yang dijelaskan di atas:

  • <action>: Aksi maksud.
  • <data>: Tipe data yang diterima, termasuk tipe MIME atau atribut URI data atribut lainnya (seperti skema, host, porta, jalur, dan sebagainya).
  • <category>: Kategori maksud.

Misalnya, aktivitas utama untuk aplikasi Anda menyertakan elemen <intent-filter> ini, yang telah Anda lihat di bab sebelumnya:

<intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

Filter maksud ini memiliki aksi MAIN dan kategori LAUNCHER. Elemen <action> menetapkan bahwa ini adalah titik masuk “utama” ke aplikasi. Elemen <category> menetapkan bahwa aktivitas ini harus dicantumkan dalam peluncur aplikasi sistem (untuk memungkinkan pengguna meluncurkan aktivitas ini). Hanya aktivitas utama untuk aplikasi Anda yang harus memiliki filter maksud ini.

Inilah contoh lain maksud implisit untuk berbagi sedikit teks. Filter maksud ini mencocokkan contoh maksud implisit dari bagian sebelumnya:

<activity android:name="ShareActivity">
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain"/>
    </intent-filter>
</activity>

Anda bisa menetapkan lebih dari satu aksi, data, atau kategori untuk filter maksud yang sama, atau memiliki beberapa filter maksud per aktivitas untuk menangani jenis maksud yang berbeda.

Sistem Android akan menguji maksud implisit terhadap filter maksud dengan membandingkan bagian maksud tersebut dengan ketiga elemen filter maksud (aksi, kategori, dan data). Maksud harus lulus ketiga pengujian atau sistem Android tidak akan mengirim maksud ke komponen. Akan tetapi, karena sebuah komponen mungkin memiliki beberapa filter maksud, maksud yang tidak lulus salah satu filter komponen mungkin saja lulus di filter lainnya.

Tindakan

Filter maksud bisa mendeklarasikan nol atau beberapa elemen <action> untuk aksi maksud. Aksi didefinisikan dalam atribut nama, dan berisi string “android.intent.action.” ditambah nama aksi maksud, tanpa awalan ACTION_. Jadi, misalnya, maksud implisit dengan aksi ACTION_VIEW cocok dengan filter maksud yang aksinya adalah android.intent.action.VIEW.

Misalnya, filter maksud ini cocok dengan ACTION_EDIT dan ACTION_VIEW:

<intent-filter>
    <action android:name="android.intent.action.EDIT" />
    <action android:name="android.intent.action.VIEW" />
    ...
</intent-filter>

Untuk melewati filter ini, aksi yang ditetapkan dalam objek Intent yang masuk harus cocok dengan setidaknya salah satu tindakan. Anda harus menyertakan setidaknya satu aksi maksud untuk mencocokkan maksud implisit yang masuk.

Kategori

Filter maksud bisa mendeklarasikan nol atau beberapa elemen <category> untuk kategori maksud. Kategori didefinisikan dalam atribut nama, dan berisi string “android.intent.category.” ditambah nama kategori maksud, tanpa awalan CATEGORY.

Misalnya, filter maksud ini cocok dengan CATEGORY_DEFAULT dan CATEGORY_BROWSABLE:

<intent-filter>
    <category android:name="android.intent.category.DEFAULT" /> 
    <category android:name="android.intent.category.BROWSABLE" />
    ...
</intent-filter>

Perhatikan, semua aktivitas yang Anda inginkan untuk menerima maksud implisit harus menyertakan filter maksud android.intent.category.DEFAULT. Kategori ini diterapkan ke semua objek Intent implisit oleh sistem Android.

Data

Filter maksud bisa mendeklarasikan nol atau beberapa elemen <data> untuk URI yang dimuat dalam data maksud. Karena data maksud terdiri dari URI dan (opsional) tipe MIME, Anda bisa membuat filter maksud untuk beragam aspek data itu, termasuk:

  • Skema URI
  • Host URI
  • Jalur URI
  • Tipe MIME

Misalnya, filter maksud ini mencocokkan maksud data dengan skema URI http dan tipe MIME “video/mpeg” atau “audio/mpeg”.

<intent-filter> 
    <data android:mimeType="video/mpeg" android:scheme="http" /> 
    <data android:mimeType="audio/mpeg" android:scheme="http" />
    ...
</intent-filter>

Berbagi data dengan ShareCompat.IntentBuilder

Tindakan berbagi adalah cara mudah bagi pengguna untuk berbagi item di aplikasi dengan jaringan sosial dan aplikasi lainnya. Meskipun Anda bisa membangun aksi berbagi di aplikasi sendiri menggunakan maksud implisit dengan aksi ACTION_SEND, Android menyediakan kelas helper ShareCompat.IntentBuilder agar mudah mengimplementasikan berbagi di aplikasi.

Catatan:Untuk aplikasi yang menargetkan rilis Android setelah API 14, Anda bisa menggunakan kelas ShareActionProvider untuk tindakan berbagi sebagai ganti ShareCompat.IntentBuilder. Kelas ShareCompat adalah bagian dari pustaka dukungan V4, dan memungkinkan Anda untuk menyediakan tindakan berbagi di aplikasi yang kompatibel-mundur. ShareCompat menyediakan API tunggal untuk berbagi pada perangkat Android lama dan baru. Anda mengetahui selengkapnya tentang pustaka dukungan Android dalam bab berikutnya.

Dengan kelas ShareCompat.IntentBuilder, Anda tidak perlu membuat atau mengirim maksud implisit untuk aksi berbagi. Gunakan metode di ShareCompat.IntentBuilder untuk menunjukkan data yang ingin dibagikan serta informasi tambahan. Mulai dengan metode from() untuk membuat builder maksud baru, tambahkan metode lain untuk menambahkan lebih banyak data, dan akhiri dengan metode startChooser() untuk membuat dan mengirim maksud. Anda bisa merangkai metode seperti ini:

ShareCompat.IntentBuilder
    .from(this)         // information about the calling activity
    .setType(mimeType)  // mime type for the data
    .setChooserTitle("Share this text with: ") //title for the app chooser
    .setText(txt)       // intent data
    .startChooser();    // send the intent

Mengelola tugas dan aktivitas

Di bab sebelumnya, Anda telah mempelajari tentang tugas dan back-stack, yakni tempat tugas untuk aplikasi yang berisi tumpukannya sendiri bagi aktivitas yang telah dikunjungi pengguna saat menggunakan aplikasi Anda. Saat pengguna menyusuri aplikasi, instance aktivitas tugas itu akan didorong dan dimunculkan dari tumpukan untuk tugas itu.

Umumnya navigasi pengguna dari aktivitas ke aktivitas dan kembali lagi melalui tumpukan secara langsung. Bergantung pada desain dan navigasi aplikasi Anda, mungkin ada komplikasi, khususnya dengan aktivitas yang dimulai dari aplikasi lain dan tugas lain.

Misalnya, katakanlah Anda memiliki aplikasi dengan tiga aktivitas: A, B, dan C. A meluncurkan B bersama sebuah maksud, dan B meluncurkan C. C, sebaliknya mengirimkan maksud untuk meluncurkan A. Dalam hal ini, sistem membuat instance kedua dari A di bagian atas tumpukan, dibandingkan memberikan instance yang sudah berjalan ke latar depan. Bergantung pada cara mengimplementasikan aktivitas, dua instance dari A bisa menjadi tidak sinkron dan memberikan pengalaman membingungkan pada pengguna saat menyusuri kembali melalui tumpukan.Beberapa instance aktivitas dalam tugas yang sama

Atau, katakanlah aktivitas C Anda bisa diluncurkan dari aplikasi kedua bersama sebuah maksud implisit. Pengguna menjalankan aplikasi kedua, yang memiliki tugas dan back-stack sendiri. Jika aplikasi itu menggunakan maksud implisit untuk meluncurkan aktivitas C Anda, instance C akan baru dibuat dan ditempatkan pada back-stack untuk tugas aplikasi kedua itu. Aplikasi Anda tetap memiliki tugas, back-stack, dan instance C sendiri.Beberapa instance aktivitas dalam tugas berbeda

Kebanyakan perilaku default Android untuk tugas dan aktivitas berfungsi dengan baik dan Anda tidak perlu khawatir tentang cara aktivitas dikaitkan dengan tugas atau bagaimana aktivitas bisa ada di back-stack. Jika Anda ingin mengubah perilaku normal, Android menyediakan sejumlah cara untuk mengelola tugas dan aktivitas dalam tugas tersebut, termasuk:

  • Mode peluncuran aktivitas, untuk menentukan cara meluncurkan aplikasi.
  • Afinitas tugas, yang menunjukkan tugas mana yang memiliki aktivitas yang diluncurkan.

Mode Peluncuran Aktivitas

Gunakan mode peluncuran aktivitas untuk menunjukkan cara memperlakukan aktivitas baru bila diluncurkan—yakni jika aktivitas harus ditambahkan ke tugas saat ini, atau diluncurkan ke dalam tugas baru. Definisikan mode peluncuran untuk aktivitas bersama atribut di elemen <activity> manifes Android, atau bersama flag yang disetel pada maksud yang memulai aktivitas itu.

Atribut aktivitas

Untuk mendefinisikan mode peluncuran aktivitas, tambahkan atribut android:launchMode ke elemen <activity> di manifes Android. Contoh ini menggunakan mode peluncuran “standar”, yang merupakan default.

<activity
   android:name=".SecondActivity"
   android:label="@string/activity2_name"
   android:parentActivityName=".MainActivity"
   android:launchMode="standard">
   ...
</activity>

Ada empat mode peluncuran yang tersedia sebagai bagian dari elemen <activity> :

  • “standard” (default): Aktivitas baru diluncurkan dan ditambahkan ke back-stack untuk tugas saat ini. Aktivitas bisa dibuat instance-nya beberapa kali, tugas tunggal bisa memiliki beberapa instance aktivitas yang sama, dan beberapa instance bisa dimiliki oleh tugas yang berbeda.
  • “singleTop”: Jika instance aktivitas ada di bagian atas back-stack tugas saat ini dan permintaan maksud untuk aktivitas tersebut datang, Android akan merutekan maksud tersebut ke instance aktivitas yang ada, bukan membuat instance baru. Aktivitas baru tetap dibuat instance-nya jika masih ada aktivitas di back-stack selain di bagian atas.
  • “singleTask”: Bila aktivitas diluncurkan, sistem akan membuat tugas baru untuk aktivitas itu. Jika tugas lain sudah ada dengan instance aktivitas itu, sistem akan merutekan maksud ke aktivitas itu sebagai gantinya.
  • “singleInstance”: Sama seperti tugas tunggal, hanya saja sistem tidak meluncurkan aktivitas lain ke dalam tugas yang berisi instance aktivitas. Aktivitas akan selalu tunggal dan satu-satunya anggota tugasnya.

Sebagian besar aplikasi hanya akan menggunakan mode peluncuran standar atau singleTop. Lihat dokumentasi atribut launchMode untuk informasi lebih detail tentang mode peluncuran.

Flag maksud

Flag maksud merupakan opsi yang menetapkan cara aktivitas (atau komponen aplikasi lainnya) yang menerima maksud harus menangani maksud tersebut. Flag maksud didefinisikan sebagai konstanta di kelas Intent dan dimulai dengan kata FLAG_. Anda menambahkan flag maksud ke objek Intent dengan setFlag() atau addFlag().

Tiga flag maksud spesifik digunakan untuk mengontrol mode peluncuran aktivitas, baik yang berhubungan dengan atribut launchMode atau yang menggantikannya. Flag maksud selalu diutamakan daripada mode peluncuran jika terjadi konflik.

  • FLAG_ACTIVITY_NEW_TASK: memulai aktivitas di tugas baru. Ini adalah perilaku yang sama dengan mode peluncuran singleTask.
  • FLAG_ACTIVITY_SINGLE_TOP: jika aktivitas yang diluncurkan berada di bagian atas back-stack, rutekan maksud ke instance aktivitas yang ada tersebut. Jika tidak, buat instance aktivitas baru. Ini adalah perilaku yang sama dengan mode peluncuran singleTop.
  • FLAG_ACTIVITY_CLEAR_TOP: Jika instance aktivitas yang akan diluncurkan sudah ada di back-stack, musnahkan aktivitas lain di atasnya dan rutekan maksud ke instance yang ada. Bila digunakan bersama-sama dengan FLAG_ACTIVITY_NEW_TASK, flag ini berada di instance aktivitas yang ada dalam tugas apa pun dan membawanya ke latar depan.

Lihat kelas Intent untuk informasi selengkapnya tentang flag maksud yang tersedia.

Tangani maksud baru

Bila sistem Android merutekan maksud ke instance aktivitas yang ada, sistem akan memanggil metode callback onNewIntent() (biasanya persis sebelum metode onResume()). Metode onNewIntent() menyertakan argumen untuk maksud baru yang dirutekan ke aktivitas. Ganti metode onNewIntent() dalam kelas Anda untuk menangani informasi dari maksud baru tersebut.

Perhatikan, metode getIntent()—untuk mendapatkan akses ke maksud yag meluncurkan aktivitas—selalu mempertahankan maksud asal yang meluncurkan instance aktivitas. Panggil setIntent() dalam metode onNewIntent():

@Override
public void onNewIntent(Intent intent) {
    super.onNewIntent(intent);

    // Use the new intent, not the original one
    setIntent(intent);
}

Panggilan ke getIntent() setelah ini akan mengembalikan maksud baru.

Afinitas Tugas

Afinitas tugas menunjukkan tugas yang sebaiknya memiliki aktivitas pilihan bila instance aktivitas itu diluncurkan. Secara default, semua aktivitas dimiliki aplikasi yang meluncurkannya. Aktivitas dari luar aplikasi yang diluncurkan bersama maksud implisit dimiliki aplikasi yang mengirim maksud implisit.

Untuk mendefinisikan afinitas tugas, tambahkan atribut android:taskAffinity ke elemen <activity> di manifes Android. Afinitas tugas default adalah nama paket untuk aplikasi (yang dideklarasikan di . Nama tugas baru harus unik dan berbeda dari nama paket. Contoh ini menggunakan “com.example.android.myapp.newtask” untuk nama afinitas.

<activity
   android:name=".SecondActivity"
   android:label="@string/activity2_name"
   android:parentActivityName=".MainActivity"
   android:taskAffinity="com.example.android.myapp.newtask">
   ...
</activity>

Afinitas tugas biasanya digunakan bersama-sama dengan mode peluncuran singleTask atau flag maksud FLAG_ACTIVITY_NEW_TASK untuk menempatkan aktivitas baru dalam tugas yang diberi nama sendiri. Jika tugas baru sudah ada, maksud akan dirutekan ke tugas dan afinitas itu.

Penggunaan afinitas tugas lainnya adalah pengindukan ulang, yang memungkinkan tugas dipindahkan dari aktivitas yang semula meluncurkannya ke aktivitas yang menjadi afinitasnya. Untuk mengaktifkan pengindukan ulang atas tugas, tambahkan atribut afinitas tugas ke elemen <activity> dan setel android:allowTaskReparenting ke true.

+
<activity
   android:name=".SecondActivity"
   android:label="@string/activity2_name"
   android:parentActivityName=".MainActivity"
   android:taskAffinity="com.example.android.myapp.newtask"
   android:allowTaskReparenting="true" >
   ...
</activity>