Pengertian Fragment
Fragment mewakili perilaku atau bagian dari antarmuka pengguna dalam Activity. Anda bisa mengombinasikan beberapa fragmen dalam satu aktivitas untuk membangun UI multipanel dan menggunakan kembali sebuah fragmen dalam beberapa aktivitas. Anda bisa menganggap fragmen sebagai bagian modular dari aktivitas, yang memiliki daur hidup sendiri, menerima kejadian masukan sendiri, dan yang bisa Anda tambahkan atau hapus saat aktivitas berjalan (semacam “sub aktivitas” yang bisa digunakan kembali dalam aktivitas berbeda).
Fragmen harus selalu tersemat dalam aktivitas dan daur hidup fragmen secara langsung dipengaruhi oleh daur hidup aktivitas host-nya. Misalnya, saat aktivitas dihentikan sementara, semua fragmen di dalamnya juga dihentikan sementara, dan bila aktivitas dimusnahkan, semua fragmen juga demikian. Akan tetapi, saat aktivitas berjalan (dalam status daur hidup dilanjutkan, Anda bisa memanipulasi setiap fragmen secara terpisah, seperti menambah atau membuangnya. Saat melakukan transaksi fragmen, Anda juga bisa menambahkannya ke back-stack yang dikelola oleh aktivitas —setiap entri back-stack merupakan catatan transaksi fragmen yang terjadi. Dengan back-stack pengguna dapat membalikkan transaksi fragmen (mengarah mundur), dengan menekan tombol Kembali.
Bila Anda menambahkan fragmen sebagai bagian dari layout aktivitas, fragmen itu akan berada dalam ViewGroup di hierarki tampilan aktivitas tersebut dan fragmen mendefinisikan layout tampilannya sendiri. Anda bisa menyisipkan fragmen ke dalam layout aktivitas dengan mendeklarasikan fragmen dalam file layout aktivitas, sebagai elemen <fragment>, atau dari kode aplikasi dengan menambahkannya ke ViewGroup yang ada. Akan tetapi, fragmen tidak harus menjadi bagian dari layout aktivitas; Anda juga bisa menggunakan fragmen tanpa UI-nya sendiri sebagai pekerja tak terlihat untuk aktivitas tersebut.Dokumen ini menjelaskan cara membangun aplikasi menggunakan fragmen, termasuk cara fragmen mempertahankan statusnya bila ditambahkan ke back-stack aktivitas, berbagi kejadian dengan aktivitas, dan fragmen lain dalam aktivitas, berkontribusi pada bilah aksi aktivitas, dan lainnya.
Membuat Fragmen
Daur hidup fragmen (saat aktivitasnya berjalan).
Untuk membuat fragmen, Anda harus membuat subkelas Fragment (atau subkelasnya yang ada). Kelas Fragment memiliki kode yang mirip seperti Activity. Kelas ini memiliki metode callback yang serupa dengan aktivitas, seperti onCreate(), onStart(), onPause(), dan onStop(). Sebenarnya , jika Anda mengkonversi aplikasi Android saat ini untuk menggunakan fragmen, Anda mungkin cukup memindahkan kode dari metode callback aktivitas ke masing-masing metode callback fragmen.
Biasanya, Anda harus mengimplementasikan setidaknya metode daur hidup berikut ini:
onCreate()
Sistem akan memanggilnya saat membuat fragmen. Dalam implementasi, Anda harus melakukan inisialisasi komponen penting dari fragmen yang ingin dipertahankan saat fragmen dihentikan sementara atau dihentikan, kemudian dilanjutkan.
onCreateView()
Sistem akan memanggilnya saat fragmen menggambar antarmuka penggunanya untuk yang pertama kali. Untuk menggambar UI fragmen, Anda harus mengembalikan View dari metode ini yang menjadi akar layout fragmen. Hasil yang dikembalikan bisa berupa null jika fragmen tidak menyediakan UI.
onPause()
Sistem akan memanggil metode ini sebagai indikasi pertama bahwa pengguna sedang meninggalkan fragmen Anda (walau itu tidak selalu berarti fragmen sedang dimusnahkan). Inilah biasanya tempat Anda harus mengikat setiap perubahan yang harus dipertahankan selepas sesi pengguna saat ini (karena pengguna mungkin tidak kembali).
Kebanyakan aplikasi harus mengimplementasikan setidaknya tiga metode ini untuk setiap fragmen, namun ada beberapa metode callback lain yang juga harus Anda gunakan untuk menangani berbagai tahap daur hidup fragmen. Semua metode callback daur hidup akan dibahas secara lebih detail, di bagian tentang Menangani Daur Hidup Fragmen.
Ada juga beberapa subkelas yang mungkin perlu diperpanjang, sebagai ganti kelas basis Fragment:
DialogFragment
Menampilkan dialog mengambang. Penggunaan kelas ini untuk membuat dialog merupakan alternatif yang baik dari penggunaan metode helper dialog di kelas Activity, karena Anda bisa menyatukan dialog fragmen ke dalam back-stack fragmen yang dikelola oleh aktivitas, sehingga pengguna bisa menutup ke fragmen yang ditinggalkan.
ListFragment
Menampilkan daftar item yang dikelola oleh adaptor (misalnya SimpleCursorAdapter), serupa dengan ListActivity. Menampilkan beberapa metode pengelolaan tampilan daftar seperti callback onListItemClick() untuk menangani kejadian klik.
PreferenceFragment
Menampilkan hierarki objek Preference sebagai daftar, serupa dengan PreferenceActivity. Hal ini berguna saat membuat aktivitas “setelan” untuk aplikasi Anda.
Menambahkan Fragment Pada Activity
Biasanya, fragmen berkontribusi pada sebagian UI ke aktivitas host, yang disematkan sebagai bagian dari hierarki tampilan keseluruhan aktivitas. Ada dua cara untuk menambahkan fragmen ke layout aktivitas:
1. Deklarasikan fragmen dalam file layout aktivitas.
Dalam hal ini, Anda bisa menetapkan properti layout fragmen seakan-akan sebuah tampilan. Misalnya, berikut ini adalah file layout untuk aktivitas dengan dua fragmen:
Atribut android:name dalam <fragment> menetapkan kelas Fragment untuk dibuat instance-nya dalam layout.
Saat sistem membuat layout aktivitas, sistem membuat instance setiap fragmen sebagaimana yang ditetapkan dalam layout dan memanggil metode onCreateView() masing-masing, untuk mengambil setiap fragmen. Sistem akan menyisipkan View yang dikembalikan oleh fragmen secara langsung, menggantikan elemen <fragment>.
2. Atau, secara programatis tambahkan fragmen ke ViewGroup yang ada.
Kapan saja saat aktivitas berjalan, Anda bisa menambahkan fragmen ke layout aktivitas. Anda cukup menetapkan ViewGroup di tempat memasukkan fragmen.
Untuk membuat transaksi fragmen dalam aktivitas (seperti menambah, membuang, atau mengganti fragmen), Anda harus menggunakan API dari FragmentTransaction. Anda bisa mengambil instance FragmentTransaction dari Activity seperti ini:
Selanjutnya Anda bisa menambahkan fragmen menggunakan metode add(), dengan menetapkan fragmen yang akan ditambahkan dan tampilan tempat menyisipkannya. Misalnya:
Argumen pertama yang diteruskan ke add() adalah ViewGroup tempat fragmen harus dimasukkan, yang ditetapkan oleh ID sumber daya, dan parameter kedua merupakan fragmen yang akan ditambahkan.
Setelah membuat perubahan dengan FragmentTransaction, Anda harus memanggil commit() untuk menerapkan perubahan.
Membuat UI yang Fleksibel dengan Fragment
Ketika mendesain aplikasi kita untuk mendukung ukuran layar yang berbeda-beda, kita bisa menggunakan kembali ‘fragment-fragment’ kita dalam berbagai konfigurasi layout yang berbeda-beda untuk mengoptimalkan ‘user experience’ berdasarkan ruang layar yang tersedia.
Contohnya, pada perangkat handset mungkin akan pas untuk menampilkan hanya satu ‘fragment’ dalam satu saat untuk UI ‘single-pane’. Sebaliknya, kita mungkin ingin men-set ‘fragment-fragment’ saling ber-sisi-an (bersebelahan) pada perangkat tablet yang memiliki ukuran layar yang lebih lebar untuk menampilkan informasi yang lebih banyak ke user.
Dua ‘fragment’, yang ditampilkan dalam konfigurasi yang berbeda untuk ‘activity’ yang sama. Di layar besar, kedua ‘fragment’ bisa tepat ber-sisi-an (bersebelahan), tetapi pada perangkat handset, hanya satu ‘fragment’ bisa tepat tampil sehingga ‘fragment-fragment’ harus saling bergantian satu sama lain sesuai navigasi user.
Class ‘FragmentManager’ menyediakan method-method yang membebaskan kita untuk menambahkan, memindahkan/menghilangkan, mengganti ‘fragment-fragment’ ke ‘activity’ saat runtime supaya bisa membuat tampilan yang dinamis.
Menambahkan ‘Fragment’ ke ‘Activity’ saat Runtime
Daripada membuat ‘fragment-fragment’ untuk suatu ‘activity’ di dalam file layout — seperti yang ditunjukkan dalam dengan elemen <fragment> — kita bisa menambahkan suatu fragment ke ‘activity’ saat runtime. Ini diperlukan bila kita berencana mengubah ‘fragment-fragment’ selama hidup ‘activity’.
Untuk melakukan suatu transaksi seperti menambahkan atau menghilangkan suatu ‘fragment’, kita harus menggunakan ‘FragmentManager’ untuk membuat suatu ‘FragmentTransaction’, yang menyediakan API-API untuk menambahkan, menghilangkan, mengganti, dan melakukan transaksi-transaski ‘fragment’ lainnya.
Bila ‘activity’ kita memperbolehkan ‘fragment-fragment’ tersebut untuk dihilangkan dan diganti, kita seharusnya menambahkan ‘fragment’ di saat awal ke ‘activity’ pada method ‘onCreate()’ di ‘activity’ tersebut.
Aturan penting ketika menerapkan ‘fragment’ — terutama ketika menambahkan ‘fragment-fragment’ saat runtime — adalah bahwa layout ‘activity’ kita harus memasukkan suatu kontainer ‘View’ dimana kita bisa memasukkan/menempatkan ‘fragment’ tersebut.
Layout berikut adalah suatu alternatif dari layout yang ditunjukkan pada latihan sebelumnya yang menampilkan hanya satu fragment saja dalam satu saat. Supaya bisa mengganti satu ‘fragment’ dengan ‘fragment’ yang lain, layout ‘activity’ akan memasukkan ‘FrameLayout’ kosong yang akan bertindak sebagai kontainer ‘fragment’.
Perhatikan bahwa nama file-nya adalah sama dengan file layout dalam latihan sebelumnya, tetapi direktori layout tidak memiliki qualifier ‘large’, sehingga layout ini digunakan ketika layar perangkat lebih kecil dibanding ‘large’ karena layar tersebut tidak akan cocok dengan kedua ‘fragment’ pada saat yang sama.
“res/layout/news_articles.xml“:
Di dalam ‘activity’ kita, panggillah ‘getSupportFragmentManager()’ untuk mendapat ‘FragmentManager’ yang menggunakan API-API library pendukung. Kemudian panggillah ‘beginTransaction()’ untuk membuat suatu ‘FragmentTransaction’ dan panggillah ‘add()’ untuk menambahkan satu ‘fragment’.
Kita bisa melakukan banyak transaksi ‘fragment’ untuk ‘activity’ yang menggunakan ‘FragmentTransaction’ yang sama. Ketika kita siap untuk membuat perubahan, kita harus memanggil ‘commit()’.
Contohnya, dibawah ini adalah bagaimana kita menambahkan suatu ‘fragment’ ke layout sebelumnya:
Karena ‘fragment’ tersebut sudah ditambahkan ke kontainer ‘FrameLayout’ saat runtime — sebagai ganti dari mendefinisikannya di dalam layout ‘activity’ dengan menggunakan elemen <fragment> — ‘activity’ tersebut bisa menghilangkan ‘fragment’ tersebut dan menggantinya dengan ‘fragment’ yang lain.
Berkomunikasi dengan Fragment yang lain
Untuk memanfaatkan komponen-komponen UI Fragment, kita sebaiknya membuat masing-masing komponen sebagai komponen modular secara utuh yang mendefinisikan layout dan perilakunya sendiri. Setelah kita mendefiniskan ‘Fragment-fragment’, kita bisa mengaitkan/mengasosiasikannya dengan suatu ‘Activity’ dan menghubungkannya dengan lojik aplikasi untuk merealisasikan keseluruhan UI gabungan tersebut.
Seringkali kita ingin satu ‘fragment’ untuk berkomunikasi dengan ‘fragment’ yang lain, contohnya untuk mengubah konten berdasarkan suatu ‘event’ user. Semua komunikasi ‘fragment-ke-fragment’ dilakukan melalui ‘Activity’ yang terasosiasi/terkait. Dua ‘fragment’ seharusnya tidak pernah berkomunikasi secara langsung.
Membuat ‘Interface’
Untuk membuat suatu ‘Fragment’ berkomunikasi hingga ‘Activity’ nya, kita bisa membuat interface di dalam class ‘Fragment’ dan mengimplementasikannya di dalam ‘Activity’. ‘Fragment’ akan menangkap implementasi interface pada method (siklus hidup) ‘onAttach()’ dan kemudian bisa memanggil method-method ‘Interface’ untuk berkomunikasi dengan ‘Activity’ tersebut.
Berikut dibawah ini adalah contoh komunikasi ‘Fragment’ ke ‘Activity’:
Sekarang ‘fragment’ tersebut bisa mengirim pesan ke ‘activity’ dengan memanggil method ‘onArticleSelected()’ (atau method-method lainnya di dalam ‘interface’) dengan menggunakan instan ‘mCallback’ dari interface ‘onHeadlineSelectedListener’.
Contohnya, method berikut ini di dalam ‘fragment’ dipanggil ketika user men-klik pada daftar item. ‘Fragment’ tersebut akan menggunakan ‘interface’ untuk mengirim ‘event’ ke ‘activity’ induknya.
Mengimplementasikan ‘Interface’
Untuk menerima ‘event’ dari ‘fragment’, ‘activity’ yang menjadi tempat penampungnya harus mengimplementasikan ‘interface’ yang didefinisikan di dalam class ‘fragment’.
Contohnya, ‘activity’ berikut ini akan mengimplementasikan ‘interface’ dari contoh di atas tadi.
Mengirim Pesan ke ‘Fragment’
‘Activity’ yang menjadi tempat penampung bisa mengirim pesan ke suatu ‘fragment’ dengan menangkap instan ‘Fragment’ dengan cara ‘findFragmentById()’, kemudian memanggil langsung method-method public dari ‘fragment’ tersebut.
Contohnya, bayangkan bahwa ‘activity’ yang ditunjukkan di atas mungkin berisi ‘fragment’ lain yang digunakan untuk menampilkan item yang ditentukan oleh data yang dihasilkan (dikembalikan) di dalam method di atas. Dalam kasus ini, ‘activity’ bisa melewatkan informasi yang diterima di dalam method tersebut ke ‘fragment’ lainnya yang akan menampilkan item:
File Presentasi dapat di lihat Disini
Daftar Pustaka
https://www.codepolitan.com/membuat-dan-menggunakan-fragment-59f80eff061a4
https://developer.android.com/guide/components/fragments.html?hl=id
https://phpisus.blogspot.sg/2016/10/berkomunikasi-dengan-fragment-yang-lain.html
https://phpisus.blogspot.sg/2016/10/membuat-ui-yang-fleksibel.html