1. Activities and Intents
CHAPTER 3
Activities and Intents

2. Chapter objectives: Explore an Activity’s Lifecycle
Learn about saving and restoring an Activity
Understand Intents and how they are used with multiple Activities
Become familiar with passing data between Activities
Implement applications that require basic animation Activity transitions
Study Scene transitions

3. 3.1 Activity Lifecycle
All applications are composed of at least one Activity class
In most cases, applications will require the use of several activities
Activities in an application are often loosely connected to each other. Information can be passed from one activity to another, but they remain distinct and separate in every other way.
Every application has one activity class that serves as the main activity
Each time a new activity starts, the previous activity is paused and its status is preserved by the Android system.

4. Activities must be declared in the AndroidManifest
Activities must be declared in the AndroidManifest.xml file in order to be accessible to the system
Activities are defined using the <activity> tag.
An <activity> must be added as a child to the <application> element

5. The activities in an application are implemented as a subclass of Activity
The Activity class is an important part of every application’s overall lifecycle
When an application is first loaded, its main activity, specified within the AndroidManifest, is immediately created
Once the main activity is started, it is given a window in which to draw its layout
Its layout is its associated user interface screen.

6.  The Activities in an application are managed by an Activity stack
New activities are pushed onto the top of the stack and become the running activity

7. The Activity class defines the following seven callback methods, beginning with the creation of the Activity and ending with its destruction 
onCreate() 
onStart() 
onResume() 
onPause() 
onStop() 
onRestart() 
onDestroy() 

8. If a paused or stopped activity requires destruction due to a system need for more memory, the activity will need to be recreated again. This will be done by calling onCreate(). 
onStart() is always to be called after onRestart() 
onStop() is called when the activity is no longer visible to the user
onDestroy() performs final cleanup prior to an activity’s destruction

10. 3.2 Starting, Saving, and Restoring an Activity
When an activity is paused or stopped, the state of the activity is retained
 When the system destroys an activity in order to recover memory, the memory for that activity object is also destroyed

11. A Bundle is a container for the activity state information that can be saved
The following is an incomplete list of these methods:
putChar()
putString()
putBoolean()
putByte()
putFloat()
putLong()
putShort()
putParcelable()  

12. Recover the saved state from the Bundle that the system passes to the activity
onCreate() and onRestoreInstanceState() callback methods receive the same Bundle object that contains the instance state information 
Check whether the activity’s state (stored in the Bundle object) is null before you attempt to read it
If it is null, then the system is creating a new instance of the Activity class, instead of restoring a previous one that was destroyed 

13. During runtime, the user may alter the screen orientation.  
The system will automatically recreate the currently running activity by calling onDestroy(), and then immediately calling onCreate().
Application adapts to new configurations by automatically reloading the application with alternative resources, such as adaptive layouts for different screen size and orientation

14. 3.3 Multiple Activities and the Intent Class
Applications that are built with multiple activities need to utilize the Intent class
This class provides the framework for the navigation from one screen to another.
An Intent object is a message from one component to another component, either within the application or outside the application  

15. Intents are designed to communicate messages between three application core components
Activities
Broadcast receivers
Service:

16. 3.3.1 Explicit Intents
Explicit Intents use a specific name when starting a component
This name will be the full Java class name of the activity or service
The most common use of an explicit Intent is the launching of a target component with a known name within the currently running application.

17. 3.3.2 Implicit Intents
Unlike an explicit Intent, an implicit Intent does not name a specific component
it declares a general action to perform, which allows a component from another app to handle it
When an implicit Intent is created, the system locates the appropriate target component by comparing the contents of the Intent to an Intent filter
Intent filters are declared in the manifest file of other apps located on a given device
When the Intent has found a match with the Intent filter, the system starts that component and delivers it to the Intent object.

18. 3.4 Handling Keyboard Visibility
Android shows or hides the soft keyboard when input focus moves into or out of an editable text field
The system also makes decisions about how your UI and the text field appear above the keyboard
It is possible to specify how you want your layout to appear when the keyboard is visible
Android gives focus to the first EditText element in the layout launched by a running activity

19. It is also possible to request the focus of a View programmatically
requestFocus can be called to give focus to a specific View or to one of its descendants
This can be useful in cases when you want to ensure that the keyboard is visible.

20. 3.5 Passing Data
The Android framework provides a simple and flexible approach to working with multiple activities
Android also offers an efficient model for passing information between various activities.  
Data can be passed as a message object to an activity implemented within the application or an activity outside of the applications 
When an Intent object is constructed, its action is specified
This represents the action we want the Intent to trigger
This action will also send data across process boundaries

21. It is possible to add extended data to a given Intent
This is done using the putExtra() method
putExtra() requires two parameters: a name for the data and a String data value
The data name must include a package prefix

22. 3.6 Basic Transitions Between Activities
The quality of an application can depend on several characteristics, such as content, usability, and design features
Enhancements made to interaction design, through the use of animation, can make a fundamental difference in the usability of an application
Interaction plays a large role
User interfaces are not static designs, but rather engaging and dynamic design patterns

23. Custom transition animations are resources that can be built by methods in XML code
The method overridePendingTransition() allows custom-built transitions to be entering and exiting activities
overridePendingTransition() requires two arguments: an enter animation implementation and an exit animation implementation

24. 3.7 Scene Transitions
KitKat, Android 4.4, has a transitions framework that supports the definition of scene transitions
Scenes are used specifically for transition animations.
Scenes can be created as a View hierarchy, much like a layout
A scene contains values of various properties in the View hierarchy
As scenes enter or exit a View hierarchy, they will be animated based on these properties