<google>BUY_KINDLE_FIRE</google>

1. Introduction to Kindle Fire App Development Essentials
   • About Kindle Fire App Development Essentials
   • Downloading the Code Samples
   • Feedback
   • Errata
     
     
2. An Overview of the Kindle Fire
   • Kindle Fire Operating System
   • Kindle Fire, the Cloud and Pricing
     
     
3. Setting up a Kindle Fire Android Development Environment
   • System Requirements
   • Installing the Java Development Kit (JDK)
   • Downloading the Android Developer Tools (ADT) Bundle
   • Installing the ADT Bundle
   • Installing the Correct Android and Kindle Fire SDK Packages
   • Making the Android SDK Tools Command-line Accessible
   • Adding the ADT Plugin to an Existing Eclipse Integration
   • Adding the ADT Plugin to an Existing Eclipse Integration
   • Adding the ADT Plugin to an Existing Eclipse Integration
     
     
4. Creating a Kindle Fire Android Virtual Device (AVD)
   • About Android Virtual Devices
   • Creating a Kindle Fire AVD
   • Starting the Emulator
   • Kindle Fire AVD Command-line Creation
   • Android Virtual Device Configuration Files
   • Moving and Renaming an Android Virtual Device
     
     
5. Creating an Example Kindle Fire Android Application
   • Creating a New Android Project
   • Defining the Project Name and SDK Settings
   • Project Configuration Settings
   • Configuring the Launcher Icon
   • Creating an Activity
   • Running the Application in the AVD
   • Stopping a Running Application
   • Modifying the Example Application
   • Reviewing the Layout and Resource Files
     
     
6. Testing Android Applications on a Physical Kindle Fire Device with ADB
   • An Overview of the Android Debug Bridge (ADB)
   • Enabling ADB on the Kindle Fire Device
   • Configuring the adb to Detect a Kindle Fire Device
   • Mac OS X Kindle Fire ADB Configuration
   • Windows Kindle Fire ADB Configuration
   • Linux Kindle Fire adb Configuration
   • Testing the adb Connection
   • Manual Selection of the Application Run Target
     
     
7. An Overview of the Kindle Fire Android Architecture
   • The Android Software Stack
   • The Linux Kernel
   • Android Runtime - Dalvik Virtual Machine
   • Android Runtime – Core Libraries
   • Dalvik VM Specific Libraries
   • Java Interoperability Libraries
   • Android Libraries
   • C/C++ Libraries
   • Application Framework
   • Applications
     
     
8. The Anatomy of an Android Application
   • Android Activities
   • Android Intents
   • Broadcast Intents
   • Broadcast Receivers
   • Android Services
   • Content Providers
   • The Application Manifest
   • Application Resources
   • Application Context
     
     
9. Understanding Android Application and Activity Lifecycles
   • Android Applications and Resource Management
   • Android Process States
   • Foreground Process
   • Visible Process
   • Service Process
   • Background Process
   • Empty Process
   • Inter-Process Dependencies
   • The Activity Lifecycle
   • The Activity Stack
   • Activity States
   • Handling State Change
     
     
10. Handling Android Activity State Changes
    • The Activity Class
    • Dynamic State vs. Persistent State
    • The Android Activity Lifecycle Methods
    • Activity Lifetimes
      
      
11. Android Activity State Changes by Example

1. Saving and Restoring the User Interface State of an Android Activity
   • Saving Dynamic State
   • The Bundle Class
   • Saving the State
   • Restoring the State
   • Testing the Application
     
     
2. Understanding Android Views, View Groups and Layouts
   • Views and View Groups
   • Android Layout Managers
   • The View Hierarchy
   • Creating User Interfaces
     
     
3. Designing an Android User Interface using the Graphical Layout Tool
   • The Android Graphical Layout Tool
   • A Graphical Layout Tool Example
   • Adding an XML Resource File to the Project
   • Editing View Properties
   • Using the View Properties Sheet
   • Creating a New Activity
   • Adding the New Activity to the Manifest File
   • Running the Application
   • Manually Creating an XML Layout
   • Using the Hierarchy Viewer
     
     
4. Creating an Android User Interface in Java Code
   • Java Code vs. XML Layout Files
   • Creating Views
   • Properties and Layout Parameters
   • Creating the Example Project
   • Adding Views to an Activity
   • Setting View Properties
   • Adding Layout Parameters and Rules
   • Using View IDs
   • Converting Density Independent Pixels (dp) to Pixels (px)
     
     
5. An Overview and Example of Android Event Handling
   • Understanding Android Events
   • Event Listeners and Callback Methods
   • An Event Handling Example
   • Designing the User Interface
   • The Event Listener and Callback Method
   • Consuming Events
     
     
6. Android Touch and Multi-touch Event Handling
   • Intercepting Touch Events
   • The MotionEvent Object
   • Understanding Touch Actions
   • Handling Multiple Touches
   • An Example Multi-Touch Application
   • Designing the Activity User Interface
   • Implementing the Touch Event Listener
   • Running the Example Application
     
     
7. Android Gesture and Pinch Recognition on the Kindle Fire
   • The Android Gestures Builder Application
   • The GestureOverlayView Class
   • Detecting Gestures
   • Identifying Specific Gestures
   • Adding SD Card Support to an AVD
   • Creating a Gestures File
   • Extracting the Gestures File from the SD Card
   • Creating the Example Project
   • Designing the User Interface
   • Loading the Gestures File
   • Registering the Event Listener
   • Implementing the onGesturePerformed Method
   • Testing the Application
   • Configuring the GestureOverlayView
   • Intercepting Gestures
   • Detecting Pinch Gestures
   • A Pinch Gesture Example Project
     
     
8. An Overview of Android Intents
   • An Overview of Intents
   • Explicit Intents
   • Returning Data from an Activity
   • Implicit Intents
   • Using Intent Filters
   • Checking Intent Availability
     
     
9. Android Explicit Intents – A Worked Example
   • Creating the Explicit Intent Example Application
   • Designing the User Interface Layout for ActivityA
   • Creating the Second Activity Class
   • Creating the User Interface for ActivityB
   • Adding ActivityB to the Application Manifest File
   • Creating the Intent
   • Extracting Intent Data
   • Launching ActivityB as a Sub-Activity
   • Returning Data from a Sub-Activity
   • Testing the Application
     
     
10. Android Implicit Intents – A Worked Example
    • Creating the Implicit Intent Example Project
    • Designing the User Interface
    • Creating the Implicit Intent
    • Adding a Second Matching Activity
    • Adding the Web View to the UI
    • Obtaining the Intent URL
    • Modifying the MyWebView Project Manifest File
    • Installing the MyWebView Package on a Device
    • Testing the Application
      
      
11. Android Broadcast Intents and Broadcast Receivers
    • An Overview of Broadcast Intents
    • An Overview of Broadcast Receivers
    • Obtaining Results from a Broadcast
    • Sticky Broadcast Intents
    • The Broadcast Intent Example
    • Creating the Example Application
    • Creating and Sending the Broadcast Intent
    • Creating the Broadcast Receiver
    • Configuring a Broadcast Receiver in the Manifest File
    • Testing the Broadcast Example
    • Listening for System Broadcasts
      
      
12. A Basic Overview of Android Threads and Thread handlers
    • An Overview of Threads
    • The Application Main Thread
    • Thread Handlers
    • A Basic Threading Example
    • Creating a New Thread
    • Implementing a Thread Handler
    • Passing a Message to the Handler
      
      
13. An Overview of Android Started and Bound Services
    • Started Services
    • Intent Service
    • Bound Service
    • The Anatomy of a Service
    • Controlling Destroyed Service Restart Options
    • Declaring a Service in the Manifest File
    • Starting a Service Running on System Startup
      
      
14. Implementing an Android Started Service – A Worked Example
    • Creating the Example Project
    • Creating the Service Class
    • Adding the Service to the Manifest File
    • Starting the Service
    • Testing the IntentService Example
    • Using the Service Class
    • Creating the New Service
    • Modifying the User Interface
    • Running the Application
    • Creating a New Thread for Service Tasks
      
      
15. Android Local Bound Services – A Worked Example
    • Understanding Bound Services
    • Bound Service Interaction Options
    • A Local Bound Service Example
    • Adding a Bound Service to the Project
    • Implementing the Binder
    • Binding the Client to the Service
    • Completing the Example
    • Testing the Application
      
      
16. Android Remote Bound Services – A Worked Example
    • Client to Remote Service Communication
    • Creating the Example Application
    • Designing the User Interface
    • Implementing the Remote Bound Service
    • Configuring a Remote Service in the Manifest File
    • Launching and Binding to the Remote Service
    • Sending a Message to the Remote Service