Hirup Motekar

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

2. MEMBUAT FRAGMENT

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.

3. MENAMBAHKAN FRAGMEN KE AKTIVITAS

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:

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

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”horizontal”
android:layout_width=”match_parent”
android:layout_height=”match_parent”>
<fragment android:name=”com.example.news.ArticleListFragment”
android:id=”@+id/list”
android:layout_weight=”1″
android:layout_width=”0dp”
android:layout_height=”match_parent” />
<fragment android:name=”com.example.news.ArticleReaderFragment”
android:id=”@+id/viewer”
android:layout_weight=”2″
android:layout_width=”0dp”
android:layout_height=”match_parent” />
</LinearLayout>

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

• Atau, secara programatis tambahkan fragmen ke ViewGroupyang 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:

FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

Selanjutnya Anda bisa menambahkan fragmen menggunakan metode add(), dengan menetapkan fragmen yang akan ditambahkan dan tampilan tempat menyisipkannya. Misalnya:

ExampleFragment fragment = new ExampleFragment();
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();

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.

4. MEMBUAT UI FLEXIBLE DENGAN FRAGMENT

Saat mendesain aplikasi untuk mendukung berbagai ukuran layar, Anda bisa menggunakan kembali fragmen dalam konfigurasi layout berbeda untuk mengoptimalkan pengalaman pengguna berdasarkan ruang layar yang tersedia.

Misalnya, pada perangkat handset, bisa jadi tepat untuk menampilkan satu fragmen dalam satu waktu untuk antarmuka pengguna satu panel. Sebaliknya, Anda mungkin ingin menyetel fragmen dari sisi ke sisi pada tablet yang memiliki ukuran layar yang lebih lebar untuk menampilkan informasi lebih lanjut kepada pengguna.

Gambar 1. Dua fragmen yang ditampilkan dalam konfigurasi yang berbeda untuk aktivitas yang sama pada berbagai ukuran layar. Pada layar besar, kedua fragmen muat dari sisi ke sisi, tetapi pada perangkat handset, hanya satu fragmen muat dalam satu waktu, jadi fragmen harus menggantikan satu sama lain seiring pengguna bernavigasi.

Kelas FragmentManager menyediakan metode yang mengizinkan Anda untuk menambahkan, membuang, dan mengganti fragmen ke sebuah aktivitas pada waktu proses untuk menciptakan pengalaman dinamis.

• Menambahkan Fragmen ke Aktivitas di Waktu Proses

Ketimbang mendefinisikan fragmen untuk sebuah aktivitas di file layout—sesuai yang ditampilkan di pelajaran sebelumnya dengan elemen <fragment>—Anda dapat menambahkan satu fragmen ke aktivitas saat waktu proses aktivitas. Ini diperlukan jika Anda berencana untuk mengubah fragmen sepanjang masa hidup aktivitas.

Untuk melakukan transaksi seperti membuang fragmen, Anda harus menggunakan FragmentManager untuk membuat FragmentTransaction, yang menyediakan API untuk menambahkan, membuang, menggantikan, dan melakukan transaksi fragmen lainnya.

Jika aktivitas Anda memperbolehkan fragmen untuk dihapus dan digantikan, Anda perlu menambahkan fragmen awal ke aktivitas saat metodeonCreate() aktivitas.Aturan penting saat menangani fragmen—khususnya saat menambahkan fragmen di waktu proses—adalah bahwa layout aktivitas harus menyertakan kontainer View tempat Anda dapat menyisipkan fragmen.

Layout berikut merupakan alternatif dari layout yang ditampilkan pada pelajaran sebelumnya yang hanya menampilkan satu fragmen pada satu waktu. Untuk menggantikan satu fragmen dengan fragmen lain, layout aktivitas termasuk FrameLayout kosong yang bertindak sebagai kontainer fragmen.

Perhatikan bahwa nama file sama dengan file layout di pelajaran sebelumnya, tetapi direktori layout tidak memiliki qualifier large, jadi layout ini digunakan saat layar perangkat lebih kecil dari besar karena layar tidak memuat kedua fragmen pada waktu bersamaan.

res/layout/news_articles.xml:

<FrameLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:id=”@+id/fragment_container”
android:layout_width=”match_parent”
android:layout_height=”match_parent” />

Dalam aktivitas Anda, panggil getSupportFragmentManager() untuk mendapatkan FragmentManager menggunakan Support Library API. Lalu panggil beginTransaction() untuk membuat FragmentTransaction dan panggil add() untuk menambahkan fragmen.

Anda dapat melakukan beberapa transaksi fragmen untuk aktivitas menggunakan FragmentTransaction yang sama. Setelah Anda siap melakukan perubahan, Anda harus memanggil commit().

Misalnya, berikut cara menambahkan fragmen ke layout sebelumnya:

import android.os.Bundle;
import android.support.v4.app.FragmentActivity;

public class MainActivity extends FragmentActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.news_articles);

// Check that the activity is using the layout version with
// the fragment_container FrameLayout
if (findViewById(R.id.fragment_container) != null) {

// However, if we’re being restored from a previous state,
// then we don’t need to do anything and should return or else
// we could end up with overlapping fragments.
if (savedInstanceState != null) {
return;
}

// Create a new Fragment to be placed in the activity layout
HeadlinesFragment firstFragment = new HeadlinesFragment();

// In case this activity was started with special instructions from an
// Intent, pass the Intent’s extras to the fragment as arguments
firstFragment.setArguments(getIntent().getExtras());

// Add the fragment to the ‘fragment_container’ FrameLayout
getSupportFragmentManager().beginTransaction()
.add(R.id.fragment_container, firstFragment).commit();
}
}
}

Karena fragmen telah ditambahkan ke kontainerFrameLayout di waktu proses—ketimbang mendefinisikan layout aktivitas dengan elemen <fragment> —aktivitas dapat membuang fragmen dan menggantinya dengan fragmen berbeda.

• Mengganti Satu Fragmen dengan Fragmen Lainnya

Prosedur untuk mengganti fragmen serupa dengan menambah fragmen, namun memerlukan metode replace() bukan add().

Perhatikan bahwa saat melakukan transaksi fragmen, misalnya menggantikan atau membuang fragmen, sering kali diperlukan untuk mengizinkan pengguna bernavigasi mundur dan “mengurungkan” perubahan. Untuk mengizinkan pengguna bernavigasi mundur melalui transaksi fragmen, Anda harus memanggil addToBackStack() sebelum Anda mengikat FragmentTransaction.

Catatan: Saat Anda membuang atau mengganti fragmen dan menambahkan transaksi ke back-stack, fragmen yang dibuang akan dihentikan (tidak dihancurkan). Jika pengguna bernavigasi mundur untuk memulihkan fragmen, mulai ulang akan terjadi. Jika Anda tidak menambahkan transaksi ke back-stack, fragmen akan dihancurkan saat dihapus atau digantikan.

Contoh menggantikan satu fragmen dengan fragmen lainnya:

// Create fragment and give it an argument specifying the article it should show
ArticleFragment newFragment = new ArticleFragment();
Bundle args = new Bundle();
args.putInt(ArticleFragment.ARG_POSITION, position);
newFragment.setArguments(args);

FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

// Replace whatever is in the fragment_container view with this fragment,
// and add the transaction to the back stack so the user can navigate back
transaction.replace(R.id.fragment_container, newFragment);
transaction.addToBackStack(null);

// Commit the transaction
transaction.commit();

Metode addToBackStack() mengambil parameter string opsional yang menentukan nama unik untuk transaksi. Nama tidak diperlukan kecuali Anda melakukan operasi fragmen lanjutan menggunakan FragmentManager.BackStackEntry API.

5. KOMUNIKASI ANTAR FRAGMENT

Untuk menggunakan kembali komponen Fragment UI, Anda harus membangun masing-masing komponen komponen modular yang benar-benar mandiri, yang mendefinisikan tata letak dan tingkah lakunya sendiri. Setelah Anda mendefinisikan Fragmen yang dapat digunakan kembali ini, Anda dapat mengaitkannya dengan Aktivitas dan menghubungkannya dengan logika aplikasi untuk mewujudkan keseluruhan UI komposit.

Seringkali Anda menginginkan satu Fragmen untuk berkomunikasi dengan yang lain, misalnya untuk mengubah konten berdasarkan acara pengguna. Semua komunikasi Fragmen-ke-Fragmen dilakukan melalui Aktivitas yang terkait. Dua fragmen tidak boleh berkomunikasi secara langsung.

• Tentukan sebuah Interface

Agar Fragmen dapat berkomunikasi sesuai dengan Aktivitasnya, Anda dapat menentukan sebuah antarmuka di kelas Fragment dan menerapkannya di dalam Activity. Fragmen menangkap implementasi antarmuka selama metode siklus hidup onAttach () dan kemudian dapat memanggil metode Antarmuka untuk berkomunikasi dengan Aktivitas.

Berikut adalah contoh komunikasi Fragment to Activity:

kelas publik HeadlinesFragment meluas ListFragment {
OnHeadlineSelectedListener mCallback;

// Container Activity harus mengimplementasikan antarmuka ini
antarmuka publik OnHeadlineSelectedListener {
public void onArticleSelected (posisi int);
}

@Mengesampingkan
public void onAttach (aktivitas aktivitas) {
super.onAttach (aktivitas);

// Ini memastikan aktivitas penampung telah dilaksanakan
// antarmuka panggilan balik.  Jika tidak, itu menimbulkan pengecualian
coba {
aktivitas mCallback = (OnHeadlineSelectedListener);
} catch (ClassCastException e) {
buang ClassCastException baru (activity.toString ()
+ “harus menerapkan OnHeadlineSelectedListener”);
}
}

…
}

Sekarang fragmen tersebut dapat mengirimkan pesan ke aktivitas dengan memanggil onArticleSelected() (atau metode lain di antarmuka) dengan menggunakan instance mCallback dari antarmuka OnHeadlineSelectedListener .

Misalnya, metode berikut dalam fragmen dipanggil saat pengguna mengklik item daftar. Fragmen menggunakan antarmuka panggilan balik untuk menyampaikan acara ke aktivitas orang tua.

@Mengesampingkan
public void onListItemClick (ListView l, Lihat v, posisi int, id panjang) {
// Kirimkan acara ke aktivitas host
mCallback.onArtikel terpilih (posisi);
}

• Terapkan Interface

Untuk menerima event callback dari fragmen, aktivitas yang menghostingnya harus mengimplementasikan antarmuka yang didefinisikan di kelas fragmen.

Misalnya, aktivitas berikut mengimplementasikan antarmuka dari contoh di atas.

public static class MainActivity memperluas Aktivitas
menerapkan HeadlinesFragment.OnHeadlineSelectedListener {
…

public void onArticleSelected (posisi int) {
// Pengguna memilih judul artikel dari HeadlinesFragment
// Lakukan sesuatu di sini untuk menampilkan artikel itu
}
}

• Kirimkan Pesan ke Fragmen

Aktivitas host dapat mengirimkan pesan ke fragmen dengan menangkap contoh Fragment dengan findFragmentById() , lalu langsung memanggil metode publik fragmen tersebut.

Misalnya, bayangkan bahwa aktivitas yang ditunjukkan di atas mungkin berisi fragmen lain yang digunakan untuk menampilkan item yang ditentukan oleh data yang dikembalikan dalam metode callback di atas. Dalam kasus ini, aktivitas dapat melewati informasi yang diterima dalam metode callback ke fragmen lain yang akan menampilkan item:

public static class MainActivity memperluas Aktivitas
menerapkan HeadlinesFragment.OnHeadlineSelectedListener {
…

public void onArticleSelected (posisi int) {
// Pengguna memilih judul artikel dari HeadlinesFragment
// Lakukan sesuatu di sini untuk menampilkan artikel itu

ArtikelFragment articleFrag = (ArticleFragment)
getSupportFragmentManager () findFragmentById (R.id.article_fragment);

jika (articleFrag! = null) {
// Jika fragmen artikel tersedia, kita berada dalam tata letak dua pane …

// Panggil metode dalam ArticleFragment untuk memperbarui kontennya
articleFrag.updateArticleView (posisi);
} lain {
// Jika tidak, kita berada dalam tata letak satu pane dan harus menukar fragmen …

// Buat fragmen dan berikan argumen untuk artikel yang dipilih
ArticleFragment newFragment = new ArticleFragment ();
Bundle args = Bundle baru ();
args.putInt (ArticleFragment.ARG_POSITION, posisi);
newFragment.setArguments (args);

FragmentTransaction transaction = getSupportFragmentManager (). BeginTransaction ();

// Ganti apa pun yang ada dalam tampilan fragmen_container dengan fragmen ini,
// dan tambahkan transaksi ke tumpukan belakang sehingga pengguna bisa menavigasi kembali
transaction.replace (R.id.fragment_container, newFragment);
transaction.addToBackStack (null);

// komit transaksi
transaction.commit ();
}
}
}

DOWNLOAD PPT

Referens

https://developer.android.com/guide/components/fragments.html?hl=idhttps://developer.android.com/training/basics/fragments/communicating.html?hl=idhttps://developer.android.com/training/basics/fragments/fragment-ui.html?hl=id