Fragment Kullanımı – Fragmentlar Arası İletişim
Geliştirdiğiniz uygulamalarda kullanmış olduğunuz Fragment’ ların birbirleriyle iletişime geçmesi gerekebilir. Örneğin kullanıcının uygulama içerisinde yer alan listeye tıklayarak buna bağlı olarak bir içeriğin görüntülemesi gerekebilir. Böyle durumlarda yapılması gereken en sağlıklı yol ise, Fragment’ ların birbirleriyle doğrudan değil Activity üzerinden iletişime geçmesidir. İki fragment hiç bir şekilde birbirleriyle doğrudan iletişime geçmemelidirler. Şİmdi gelin bu işlemler nasıl yapılıyor onu görelim.
İlk olarak yapılması gereken işlem bir Interface tanımlamak olmalıdır.
1
2
3
|
public interface OnHeadlineSelectedListener {
public void onArticleSelected(int position);
}
|
Daha sonra ise interface aracılığıyla iletişimi başlatacak olan Fragment içerisinde yer alan onAttach callback metodu içerisinde container Activity’ nin bu tanımlamış olduğumuz Interface’ i implement ettiğinden emin olmalıyız.
1
2
3
4
5
6
7
8
9
10
11
12
13
|
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
// This makes sure that the container activity has implemented
// the callback interface. If not, it throws an exception
try {
mCallback = (OnHeadlineSelectedListener) activity;
} catch (ClassCastException e) {
throw new ClassCastException(activity.toString()
+ ” must implement OnHeadlineSelectedListener”);
}
}
|
Şimdi fragment onArticleSelected() metodunu kullanarak yada tanımlanan Interface içerisinde yer alan herhangi bir başka metodu kullanarak activity’ e iletmek istediği mesajı iletebilir. Örnek bir kullanım durumu aşağıdaki gibi olabilir.
1
2
3
4
5
|
@Override
public void onListItemClick(ListView l, View v, int position, long id){
// Send the event to the host activity
mCallback.onArticleSelected(position);
}
|
Şimdi sıra geldi tanımlanmış olan Interface’ in Activity tarafından implement edilmesine. Fragment içerisinde yer alan callback metodundan sağlanan içeriğin Activity içerisinde kullanılabilmesi için Activity’ nin interface’ i kesinlikle implement etmesi gerekmektedir.
1
2
3
4
5
6
7
8
9
|
public class MainActivity extends Activity
implements OnHeadlineSelectedListener{
...
public void onArticleSelected(int position) {
// The user selected the headline of an article from the HeadlinesFragment
// Do something here to display that article
}
}
|
Daha sonra burada yer alan position bilgisine göre detay sayfasında istediğiniz gibi içeriği kullanabilirsiniz. Örnek bir kullanım durumunu aşağıda paylaşıyorum.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
public class MainActivity extends Activity
implements OnHeadlineSelectedListener{
...
public void onArticleSelected(int position) {
ArticleFragment articleFrag = (ArticleFragment)
getSupportFragmentManager().findFragmentById(R.id.article_fragment);
if (articleFrag != null) {
// If article frag is available, we’re in two-pane layout…
// Call a method in the ArticleFragment to update its content
articleFrag.updateArticleView(position);
} else {
// Otherwise, we’re in the one-pane layout and must swap frags…
// Create fragment and give it an argument for the selected article
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();
}
}
}
|
İşlem örnekte görebileceğiniz üzere son derece kolay.
Şimdi sizlere bir başka alternatif kullanımdan bahsetmek istiyorum. Bazı durumlarda tanımladığınız Fragment bazı argümanlar isteyebilir. Bu gibi durumlarda genel olarak kullanılan tasarım anlayışı ise, argüman içeren bir Fragment static bir newInstance metodu kullanılarak oluşturulması şeklinde özetlenebilir. Burada ki temel mantık oluşturulan Fragment’ ın kesinlikle bir tane argüman içermeyen constructor’ a sahip olması gerekmektedir.
1
2
3
4
5
6
7
8
9
10
|
public class DemoFragment extends Fragment {
public static DemoFragment newInstance(int someInt, String someTitle) {
DemoFragment fragmentDemo = new DemoFragment();
Bundle args = new Bundle();
args.putInt(“someInt”, someInt);
args.putString(“someTitle”, someTitle);
fragmentDemo.setArguments(args);
return fragmentDemo;
}
}
|
Daha sonrasında ise onCreate metodu içerisinde bu değerleri şu şekilde kullanabilirsiniz.
1
2
3
4
5
6
7
|
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Get back arguments
int SomeInt = getArguments().getInt(“someInt”, 0);
String someTitle = getArguments().getString(“someTitle”, “”);
}
|
Fragment’ in dinamik olarak oluşturulması ise aşağıda paylaştığım şekilde olmalıdır.
1
2
3
4
|
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
DemoFragment fragmentDemo = DemoFragment.newInstance(5, “my title”);
ft.replace(R.id.your_placeholder, fragmentDemo);
ft.commit();
|
Fragment Nasıl Tanımlanır?
Bir fragment oluşturmak için, Activity yapısında olduğu gibi bir tane XML dosyasına, bir tane de Fragment yapısını kontrol edebilmek amacıyla Java dosyasına ihtiyacımız vardır.
İlk olarak her zaman olduğu gibi temel anlamda bir tane xml dosyası oluşturabilirsiniz. Bu tanımladığımız layout yapısını activity’ nin bir parçasını olarak düşünebilirsiniz.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
<?xml version=“1.0” encoding=“utf-8”?>
<LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
android:layout_width=“match_parent” android:layout_height=“match_parent”
android:orientation=“vertical” >
<TextView
android:id=“@+id/textView1”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“TextView” />
<Button
android:id=“@+id/button1”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“Button” />
</LinearLayout>
|
Bu XML dosyasına ait olan Fragment’ i kontrol etmek için kullanacağımız Java dosyasımız ise;
1
2
3
4
5
6
7
8
9
10
11
|
import android.support.v4.app.Fragment;
public class FooFragment extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Defines the xml file for the fragment
View view = inflater.inflate(R.layout.foo, container, false);
return view;
}
}
|
Activity içerisine Fragment nasıl yerleştirilir?
Bir Activity içerisine fragment yerleştirmenin iki yolu bulunmaktadır. Birincisi dinamik olarak Java kodları içerisinden eklemek, diğeri ise statik olarak XML içerisinden eklemektir.
Statik olarak eklemek
Fragment’ ı statik olarak ekleme işlemi son derece basittir. Yapmanız gereken tek işlem activity xml dosyasına <fragment> tag’i ni eklemektir.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
<?xml version=“1.0” encoding=“utf-8”?>
<LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
android:layout_width=“match_parent”
android:layout_height=“match_parent”
android:orientation=“vertical” >
<TextView
android:id=“@+id/textView1”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“TextView” />
<fragment
android:name=“com.example.android.FooFragment”
android:id=“@+id/fooFragment”
android:layout_width=“match_parent”
android:layout_height=“match_parent” />
</LinearLayout>
|
Dinamik olarak eklemek
İkinci olarak ise, Java dosyamız içerisinden FragmentManager sınıfını kullanarak dinamik olarak eklemektir. FragmentManager ve FragmentTransaction sınıfları sizlere Fragment’ lar ile işlem yaparken add, remove ve replace işlemlerini yapmanıza olanak sağlamaktadır. Dinamik olarak eklemek için yapmanız gereken şey, daha sonra add, remove, replace işlemlerini gerçekleştirebilmek amacıyla bir placeholder FrameLayout kullanmanızdır.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
<?xml version=“1.0” encoding=“utf-8”?>
<LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
android:layout_width=“match_parent”
android:layout_height=“match_parent”
android:orientation=“vertical” >
<TextView
android:id=“@+id/textView1”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“TextView” />
<FrameLayout
android:id=“@+id/your_placeholder”
android:layout_height=“match_parent”>
</FrameLayout>
</LinearLayout>
|
Bu tanımlama işlemini gerçekleştirdikten sonra ise FragmentManager kullanarak framelayout yerine fragment‘ ın yerleşmesi işlemi gerçekleştirecek olan FragmentTransaction oluşturmaktır.
1
2
3
|
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.replace(R.id.your_placeholder, new FooFragment());
ft.commit();
|
Kullanmanız gereken bütün kod satırları bu kadar. Şimdi bunları teker teker inceleme zamanı.
1
|
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
|
İlk olarak transaction işlemini başlatalım.
1
|
ft.replace(R.id.your_placeholder, new FooFragment());
|
Daha sonra ise placeholder yerine Fragment’ ın yerleşmesi işlemini sağlamak için replace metodunu kullanalım. Burada alternatif olarak aşağıda paylaştığım yapı da kullanılabilir.
1
|
ft.add(R.id.your_placeholder, new FooFragment());
|
ve en son olarak işlemin gerçekleşmesini sağlıyoruz.
1
|
ft.commit();
|