ANDROID – FRAGMENTS

Fragment
 An activity is a container for views
 When you have a larger screen device than a phone –like a
tablet it can look too simple to use phone interface here.
 → Fragments
◼ Mini-activities, each with its own set of views
◼ One or more fragments can be embedded in an Activity
◼ You can do this dynamically as a function of the device type (tablet or not) or
orientation
◼ ALSO, you can reuse fragments --- like reuse of mini interfaces
Fragment Idea
primarily to support more dynamic and
flexible UI designs on large screens, such as tablets.
 → Fragments
◼ Mini-activities, each with its own set of views
◼ One or more fragments can be embedded in an Activity
◼ You can do this dynamically as a function of the device type (tablet or not) or
orientation

You might
decide to run
a tablet in
portrait mode
with the handset
model of only
one fragment
in an Activity
 Activity=
Fragment 2 Fragments

 A Fragment represents a behavior or a portion of

user interface in an Activity.
 You can combine multiple fragments in a single
activity to build a multi-pane UI and reuse a
fragment in multiple activities.
 You can think of a fragment as a modular section of
an activity, which has its own lifecycle, receives its
own input events, and which you can add or remove
while the activity is running (sort of like a "sub
activity" that you can reuse in different activities).
Animated Illustration of Fragment as
part of UI—changing (replacing)
Starting:
Activity

TextView Fragment 1

FragementTransaction: replace
Fragment 1 with Fragment 2
Activity

TextView Fragment 2
 Fragment Lifecycle
 Fragment in an Activity---Activity
Lifecyle influences
 Activity paused → all its fragments paused
 Activity destroyed → all its fragments are destroyed
 Activity running → manipulate each fragment
independently.
 Fragment transaction →add, remove,
etc.
 adds it to a back stack that's managed by the activity—each
back stack entry in the activity is a record of the fragment
transaction that occurred.
 The back stack allows the user to reverse a fragment
transaction (navigate backwards), by pressing the Back
button.
Fragment inside Activity
 it lives in a ViewGroup inside the activity's view hierarchy
 fragment has its own view layout.
 via XML: Insert a fragment into your activity layout by
declaring the fragment in the activity's layout file, as a
<fragment> element,
 via CODE: from your application code by adding it to an
existing ViewGroup.
 you may also use a fragment without its own UI as an invisible
worker for the activity.
Fragment – extend a Fragment
class
 via CODE: extend android.app.Fragment OR one
of its subclasses (DialogFragment, ListFragment,
PreferenceFragment, WebViewFragment )
 IMPORTANT: must include a public empty constructor. The framework
will often re-instantiate a fragment class when needed, in particular during
state restore, and needs to be able to find this constructor to instantiate it. If
the empty constructor is not available, a runtime exception will occur in
some cases during state restore.
 CALL Back functions (like Activity) : examples onCreate(), onStart(),
onPause(), and onStop().
 Fragment methods (callback
functions)
 onAttach(Activity) called once the fragment is associated with its
activity.
 onCreate(Bundle) called to do initial creation of the fragment.
 onCreateView(LayoutInflater, ViewGroup, Bundle) creates and
returns the view hierarchy associated with the fragment.
 onActivityCreated(Bundle) tells the fragment that its activity has
completed its own Activity.onCreaate.
 onStart() makes the fragment visible to the user (based on its
containing activity being started).
 onResume() makes the fragment interacting with the user (based on
its containing activity being resumed).
 Fragment methods (callback
functions)
As a fragment is no longer being used, it goes through a reverse series
of callbacks:
 onPause() fragment is no longer interacting with the user either

because its activity is being paused or a fragment operation is

modifying it in the activity.
 onStop() fragment is no longer visible to the user either because its
activity is being stopped or a fragment operation is modifying it in
the activity.
 onDestroyView() allows the fragment to clean up resources

associated with its View.

 onDestroy() called to do final cleanup of the fragment's state.

 onDetach() called immediately prior to the fragment no longer

being associated with its activity.
Create your own Fragment class
OR use known sub-classes
 DialogFragment
 Displays a floating dialog. Using this class to create a dialog is a good alternative to
using the dialog helper methods in the Activity class, because you can incorporate a
fragment dialog into the back stack of fragments managed by the activity, allowing
the user to return to a dismissed fragment.

 ListFragment
 Displays a list of items that are managed by an adapter (such as a
SimpleCursorAdapter), similar to ListActivity. It provides several methods for
managing a list view, such as the onListItemClick() callback to handle click events.

 PreferenceFragment
 Displays a hierarchy of Preference objects as a list, similar to PreferenceActivity. This
is useful when creating a "settings" activity for your application.

NOTE: sometimes there are multiple ways to achive something like a List –either with ListView
or ListFragment → they have different methods and lifecycles.
Fragments and their UI
--- how to specify the UI of a Fragment
Fragments and their UI
 Most fragments will have a UI
 Will have its own layout
 you must implement the onCreateView() callback
method, which the Android system calls when it's
time for the fragment to draw its layout. Your
implementation of this method must return a View
that is the root of your fragment's layout.
◼ Note some subclasses of Fragment like ListFragment have
already implemented this method and you don’t need to
override.
 Fragments and their UI –
onCreateView() using XML
 Can implement onCreateView using XML

public static class ExampleFragment extends Fragment { Activity parent’s

ViewGroup
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {

Bundle that provides data about the previous

instance of the fragment, if the fragment is being resumed

// Inflate the layout for this fragment

return inflater.inflate(R.layout.example_fragment, container, false);
}

Have example_fragment.xml file that contains the layout

} This will be contained in resource layout folder.
Fragments –Adding to an Activity
--- what are the options: XML or via Code
OPTION1 –adding to an Activity
via Activity layout XML.
<?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.ExampleFragment "
android:id="@+id/list"
android:layout_weight="1"
android:layout_width="0dp" 2 fragment instances
android:layout_height="match_parent" />
<fragment android:name="com.example.news.ExampleFragment"
android:id="@+id/viewer"
android:layout_weight="2"
android:layout_width="0dp"
android:layout_height="match_parent" />
</LinearLayout>

Need unique ids for each so system can

restore the fragment if the activity is restarted
 OPTION2 –creating and adding to
an Activity a Fragment via CODE.
/*Inside Activity Code where you want to add Fragment (dynamically anywhere or in onCreate()
callback)
*/

//get FragmentTransaction associated with this Activity

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

//Create instance of your Fragment

ExampleFragment fragment = new ExampleFragment();
This points to the Activity ViewGroup in
which the fragment should be placed,
specified by resource ID
//Add Fragment instance to your Activity
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();
FragmentManager
--class used to manage the Fragments and can
generate a FragementTransaction from
 Managing Fragments
FragmentManager methods:
 Get fragments that exist in Activity =
 findFragmentById() (for fragments that provide a UI in the activity layout)
 findFragmentByTag() (for fragments that do or don't provide a UI).
BackStack – is owned
by an Activity and any

 Pop fragments off the back stack, Fragment you put on it means
when user hits “back” you can
pop off from the BackStack a
 popBackStack() (simulating a Back command by the user). Fragment to return to it

 Register a listener for

changes to the back stack
 addOnBackStackChangedListener().
 FragmentManager – using it to grab
“handle” of fragment referenced by id

// get FragmentManager associated with Activity

FragementManager fm = getFragmentManager();

// Suppose you have a Fragement class called DetailFragmentsand you

// now it was created using id “details”
DetailsFragment details = (DetailsFragment)
getFragmentManager().findFragmentById(R.id.details);

Note: the id used to create the Fragment previous was

“details”

//Now you can call any methods you want on the details fragment
*******
FragmentTransaction
Used to replace, add and remove
DYNAMICALLY fragments
How to create FragmentTransaction
instance
 You get it from the current FragmentManager –this
code is somewhere inside your Activity class

// get FragementTransaction from Manager

FragmentTransaction transaction = getFragmentManager().beginTransaction();
 FragmentTransaction - methods
 fragmentTransaction.add (containerViewID, fragment);
 As seen in previous slide lets you add fragment to UI with new ID

 fragmentTransaction.replace(containerViewId, fragment, tag);

 As seen in previous slide lets you replace (if there or otherwise adds)
fragment with another based on id

 fragmentTransaction.add(containerViewId, fragment, tag);

 Lets you directly add a new Fragment with a new id associated with it

 fragmentTransaction.addToBackStack(name);
 As seen in previous slide lets you add transaction to BackStack (so can return
to previous fragment state when user hits “back”)
 Example (repeated) ADDING
fragment dynamically
/*Inside Activity Code where you want to add Fragment (dynamically anywhere or in onCreate()
callback)
*/

//get FragmentTransaction associated with this Activity

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

//Create instance of your Fragment

ExampleFragment fragment = new ExampleFragment();
This points to the Activity ViewGroup in
which the fragment should be placed,
specified by resource ID
//Add Fragment instance to your Activity
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();
 Example REPLACING fragment dynamically

/*Inside Activity Code where you want to add Fragment (dynamically anywhere or in onCreate() callback)
*/
// STEP 1: Create new fragment and create FragementTransaction from Manager
Fragment newFragment = new ExampleFragment();
FragmentTransaction transaction = getFragmentManager().beginTransaction();

// STEP 2: Replace whatever is in the fragment_container view with this fragment

// and add the transaction to the back stack (so can navigate back)
transaction.replace(R.id.fragment_container, newFragment);
transaction.addToBackStack(null);
newFragment replaces whatever fragment (if any) that
// STEP 3: Commit the transaction is currently in the layout container identified by the
transaction.commit();
R.id.fragment_container
If you do not call addToBackStack() when you perform a transaction
that removes/replaces a fragment, then that fragment is destroyed when the
transaction is committed and the user cannot navigate back to it.
Whereas, if you do call addToBackStack() when removing/replacing a fragment,
then the fragment is stopped and will be resumed if the user navigates back.
Fragments --- MORE
---various additional concepts regarding
Fragments
There’s more you can do with
FragmentTransaction –like
animation

/ /Create and commit a new fragment transaction that adds the fragment for the back of
// the card, uses custom animations, and is part of the fragment manager's back stack.
BackFragment achterkant= BackFragment.newInstance("blabla"); getFragmentManager() .beginTransaction()

// Replace the default fragment animations with animator resources representing

// rotations when switching to the back of the card, as well as animator
// resources representing rotations when flipping back to the front (e.g. when
// the system Back button is pressed).

.setCustomAnimations( R.animator.card_flip_right_in, R.animator.card_flip_right_out, R.animator.card_flip_left_in,

R.animator.card_flip_left_out)
Fragment with NO UI
---yes, though not common you can have a
Fragment with no UI

used to provide a background behavior for the

activity without presenting additional UI.
Adding Fragment that has NO UI,
using Code
 use a fragment to provide a background behavior for the activity
without presenting additional UI.
 use add(Fragment, String) (supplying a unique string "tag" for the fragment,
rather than a view ID).
 it's not associated with a view in the activity layout, it does not receive a call to
onCreateView(). So you don't need to implement that method.

 If you want to get the fragment from the activity later, you need to use
findFragmentByTag().
 For an example activity that uses a fragment as a background worker,
without a UI, see the FragmentRetainInstance.java sample at
https://android.googlesource.com/platform/development/+/master/samp
les/ApiDemos/src/com/example/android/apis/app/FragmentRetainInstan
ce.java