1. Activities, Fragments, and Events

2. Topics Covered The life cycle of an activity
Customizing the UI using fragments
Applying styles and themes to activities
Displaying activities as dialog windows
Understanding the concept of intents
Linking activities using intent objects
Displaying alerts using notifications

3. Understanding Activities

4. What are activities? A window that contains the UI of an application
An application can have zero or more activities
Main purpose is to interact with the user
Life Cycle: the stages an activitiy goes through from the moment it appears on the screen to the moment it’s hidden.

5. Creating Activities
To create an activity, a Java class that extends the Activity base class is created.
import android.app.Activity; …
public class Activity101Activity extends Activity { }
The activity class loads it UI component using the XML file defined in the res/layout folder.

6. Declaring Activities
Each activity in the application, must be declared in the AndroidManifest.xml file.
<activity
android:name=“.Activity101Activity”>
<intent-filter></intent-filter>
</activity>

7. Activity Base Class
onCreate() – Called when the activity is first created
onStart() – Called when the activity becomes visible to the user
onResume() – Called when the activity starts interacting with the user
onPause() – Called when the current activity is being paused and the previous activity is being resumed
onStop() – Called when the activity is no longer visible
onDestroy() – Called before the activity is destroyed by the system
onRestart() – Called when the activity has been stopped and is restarting
By default

8. Figure 1: Activity Life cycle

9. Applying Styles and Themes
By default, an activity occupies the entire screen
A dialog theme can be applied to an activity so it appears as a floating dialog

10. Applying Dialog Theme <application </application>
<activity
android:name=“.Activity101Activity”>
<intent-filter></intent-filter>
</activity>
</application>
Modify the <Activity> element in the AndroidManifest.xml file by adding the android:theme attribute

11. Hiding Activity Title
import android.view.Window; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.main); }
To hide the title of an activity use the requestWindowFeature() method and pass it the Window.FEATURE_NO_TITLE constant

12. Linking Activities Using Intents
When an application has multiple activities they can be navigated through intents.
An intent is an abstract description of an operation to be performed.
An Intent provides a facility for performing late runtime binding between the code in different applications. Its most significant use is in the launching of activities, where it can be thought of as the glue between activities. It is basically a passive data structure holding an abstract description of an action to be performed.

13. Fragments

14. What is a Fragment?
A Fragment is a piece of an application's user interface or behavior that can be placed in an Activity. Interaction with fragments is done through FragmentManager, which can be obtained via Activity.getFragmentManager() and Fragment.getFragmentManager().
Some things that you can do with FragmentManager include:
Get fragments that exist in the activity, with findFragmentById() (for fragments that provide a UI in the activity layout) or findFragmentByTag() (for fragments that do or don't provide a UI).
Pop fragments off the back stack, with popBackStack() (simulating a Back command by the user).
Register a listener for changes to the back stack, with addOnBackStackChangedListener().

15. Figure 2: An example of how two UI modules defined by fragments can be combined into one activity for a tablet design, but separated for a handset design.

16. Adding Fragments Dynamically
It is more useful if fragments are created and added to activites during runtime.
Allows for a customizable UI
E.g. If the application is running on a smartphone, you might fill the activity with a single fragment; if the activity is running on a tablet, you might then fill the activity with two or more fragments.
While fragments allow UI compartmentalization into configurable parts, the real power is realized when fragments are added dynamically to activities during runtime.

17. Fragment Life Cycle
A fragment must always be embedded in an activity and the fragment's lifecycle is directly affected by the host activity's lifecycle. For example, when the activity is paused, so are all fragments in it, and when the activity is destroyed, so are all fragments.
However, while an activity is running (it is in the resumed lifecycle state), you can manipulate each fragment independently, such as add or remove them. When you perform such a fragment transaction, you can also add 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.

18. Figure 3. The lifecycle of a fragment (while its activity is running).

19. Displaying Notifications

20. For important messages the NotificationManager is used to display a persistent message at the top of the device (commonly known as the status bar, sometimes referred to as the notification bar)

21. Activities, Fragments, and Events