Activities and Intents CHAPTER 3 Activities and Intents

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.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.

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

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.

 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

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() 

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

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

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()  

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 

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

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  

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

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.

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.  

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  

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.

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

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

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

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

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 http://developer.android.com/guide/topics/resources/animation-resource.html