Previously we discuss about Android Life cycle and its methods in following posts:
- Starting an Android Activity (Activity Life Cycle in Android: Starting an Activity)
- Pausing and Resuming Activity (Activity Life Cycle in Android: Pausing and resuming an activity)
- Stopping and Re-starting Activity (Activity Life Cycle: Stopping and Restarting an Activity in Android)
- Re-creating an Activity (Activity Life Cycle in Android: Recreating an Activity)
Now in this post, we are going to discuss a very interesting component called 'Fragments'
To create a dynamic and multi-pane user interface on Android, we need to encapsulate UI components and activity behavior into modules that we can swap into and out of our activity. We can create this modules with the fragment class, which behave like a nested activity that can define its own layout and manage its own lifecycle
Having its own layout, a fragments can be configured in different combinations with the other fragments inside an activity to modify layout configurations for different screen sizes. For example, a small screen might show one fragment at a time, but a large screen can show one fragment at a time, but a large screen can show two or more.
Create a Fragment:
A fragment is like a sub-activity which we can reuse in different activities. We can achieve this by extending the Fragment class
Create a Fragment Class:
To create a fragment, first we need to create sub-class of the main fragment class. The sub-class need to include callback methods including onCreate(), onStart() , onPause() and onStop(). And the application must implement at least these three methods for every fragment:
- onCreate()
- onCreateView()
- onPause()
//Import declarations
public static class MyFragment extends Fragment {
@Overrride
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
return inflater. Inflater(R.layout.my_fragment,container, false);
}
}
Add a fragment to an Activity
After having creating the fragment class, we need to add the same fragment to an activity. For this we have two simple approaches:
· Add the fragment view in the Layout XML
· Add the fragment at runtime, using FragmentManager and FragmentTransaction class
Add the Activity to an activity using XML
We can specify the fragment in the activity’s default layout .Her we simply need to insert the following code into the activity layout file
<fragment android: name=”com.example.myApp.MyFragment “
android: id=”@+id/my_fragment”
android:layout_width=”match_parent”
android:layout_height=”match_parent” />
Add a method to an activity at the run time:
We can add fragment to Activity during runtime. Also, if we intend to remove or replace any fragment while the Activity is running, the same must be done programmatically
As per this approach we need two classes: FragmentManger and FragmentTranscation for adding the fragment programmatically. Following snippet is the code that will be involved in the process:
Fragmentmanger manager = getSupportFragmentManager();
TransactionManager transaction = manager.beginTransaction();
Transaction.add(R.layout.my_fragment, my_Fragment);
Transaction.commit();
In the above code:
The method add accepts two parameters as explained below:
1. R.layout.my_fragment: This is the unique ID that refers to the fragment layout
2. myFragment: This is the Fragment object that needs to be added to the
Activity
Replace one Fragment with Another
The procedure to replace a fragment is similar to adding one, but requires the replace () method instead of add (). Also, when we replace or remove one, it’s good to allow the user to navigate backwards and undo the changes. For this, we need to call addToBackStack() before we commit the FragmentTransaction. For Example,
//create fragment and give it an argument specifying the article it should show
MyFragment newFragment = newMyFragment();
Bundle args = new Bundle();
args.putInt(MyFragment.ARG_POSITION, postion);
newFragment.setArguments(args);
FragmentTranscation transcation = getSupportFrameManager(). beginTransaction();
// Replace whatever is in the fragment_container view with this fragment,
// 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();
Communicating with other Fragments
IF we are inclined on reusing the Fragment UI components, we‘ll need to build each fragment as self-contained, modular components. After having defined these reusable fragments, you can choose to associate each one of them with an activity, followed by connecting them with the application logic for a complete realization of the flexible UI. Here’s the 3-step process of communicating with other fragments:
Step 1: Defining an interface
Here we need to decline an interface in the main Fragment class and implement the same within the activity. The fragment will then capture the interface implementation during the execution of onAttach() method. Thus, the fragment will call the interface methods for communicating with the Activity
Public MyFragment extends ListFragment{
OnHeadLineSelecteedListener mCallback;
// Container Activity must implement this interface
public interface OnHeadlineSelectedListener {
public void onArticleSelected(int position);
}
@Override
public void oAttach(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 onHedlineSelectedListener);
}
}
Step2: Implementing the Interface
For receiving event callbacks from the main fragment class, the Activity must implement the interface that’s already been defined in the fragment class.
public static class MainActivity extends Activity implements
MyFragment.OnHeadlinSelectedListener {
public void onArticleSelected(int positon) {
}
}
Step3: Deliver a Message to a fragment
Since the host activity can easily deliver messages to a fragment by capturing the fragment instance using findFragmentById() method, it is recommended to directly call the fragment’s
public methods
public static class MainActivity extends Activity implements
MyFragment.OnHeadlinSelectedListener {
public void onArticleSelected(int positon) {
MyFragment frag = (MyFragment) getSupportFragmnetManager().findFragmentById(R.id.my_fragment);
frag.doStuff()
This post is referred from Google docs Building a Dynamic UI with Fragments
In my next post, we are going to discuss how Android app communicates with each other in Interacting one app to other app in android
