Table of Contents

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
     
     
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 - An Example Application
    • Creating the State Change Example Project
    • Designing the User Interface
    • Overriding the Activity Lifecycle Methods
    • Enabling and Filtering the LogCat Panel
    • Running the Application
    • Experimenting with the Activity
    • Saving Dynamic State
      
      
12. 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
      
      
13. Understanding Android Views, View Groups and Layouts
    • Designing for Different Kindle Fire Models
    • Views and View Groups
    • Android Layout Managers
    • The View Hierarchy
    • Creating User Interfaces
      
      
14. 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
      
      
15. 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)
      
      
16. 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
      
      
17. 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
      
      
18. Detecting Common Gestures using the Android Gesture Detector Class
    • Implementing Common Gesture Detection
    • Creating an Example Gesture Detection Project
    • Implementing the Listener Class
    • Creating the GestureDetectorCompat Instance
    • Implementing the onTouchEvent() Method
    • Testing the Application
      
      
19. Implementing Android Custom Gesture and Pinch Recognition
    • The Android Gesture Builder Application
    • The GestureOverlayView Class
    • Detecting Gestures
    • Identifying Specific Gestures
    • Adding SD Card Support to an AVD
    • Building and Running the Gesture Builder Application
    • 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
      
      
20. An Introduction to Android Fragments
    • What is a Fragment?
    • Creating a Fragment
    • Adding a Fragment to an Activity using the Layout XML File
    • Adding and Managing Fragments in Code
    • Handling Fragment Events
    • Implementing Fragment Communication
      
      
21. Using Fragments in Android - A Worked Example
    • About the Example Fragment Application
    • Creating the Example Project
    • Adding the Android Support Library
    • Creating the First Fragment Layout
    • Creating the First Fragment Class
    • Creating the Second Fragment Layout
    • Adding the Fragments to the Activity
    • Making the Toolbar Fragment Talk to the Activity
    • Making the Activity Talk to the Text Fragment
    • Testing the Application
      
      
22. Creating and Managing Android Overflow Menus on the Kindle Fire
    • The Overflow Menu
    • Creating a Overflow Menu
    • Displaying an Overflow Menu
    • Responding to Menu Item Selections
    • Creating Checkable Item Groups
    • Creating the Example Project
    • Modifying the Menu Description
    • Implementing the onOptionsItemSelected() Method
    • Testing the Application
      
      
23. An Overview of Android Intents
    • An Overview of Intents
    • Explicit Intents
    • Returning Data from an Activity
    • Implicit Intents
    • Using Intent Filters
    • Checking Intent Availability
      
      
24. 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
      
      
25. 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
      
      
26. 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
      
      
27. 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
      
      
28. 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
      
      
29. 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
      
      
30. 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
      
      
31. 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
      
      
32. An Overview of Android SQLite Databases
    • Understanding Database Tables
    • Introducing Database Schema]
    • Columns and Data Types
    • Database Rows
    • Introducing Primary Keys
    • What is SQLite?
    • Structured Query Language (SQL)
    • Trying SQLite on an Android Virtual Device (AVD)
    • Android SQLite Java Classes
    • Cursor
    • SQLiteDatabase
    • SQLiteOpenHelper
    • ContentValues
      
      
33. An Android TableLayout and TableRow Tutorial
    • The TableLayout and TableRow Layout Views
    • Creating the Database Project
    • Designing the User Interface Layout
      
      
34. An Android SQLite Database Tutorial
    • About the Database Example
    • Creating the Data Model
    • Implementing the Data Handler
    • The Add Handler Method
    • The Query Handler Method
    • The Delete Handler Method
    • Implementing the Activity Event Methods
    • Testing the Application
      
      
35. Understanding Android Content Providers
    • What is a Content Provider?
    • The Content Provider
    • onCreate()
    • query()
    • insert()
    • update()
    • delete()
    • getType()
    • The Content URI
    • The Content Resolver
    • The <provider> Manifest Element
      
      
36. Implementing an Android Content Provider
    • Copying the Database Project
    • Adding the Content Provider Package
    • Creating the Content Provider Class
    • Constructing the Authority and Content URI
    • Implementing URI Matching in the Content Provider
    • Implementing the Content Provider onCreate() Method
    • Implementing the Content Provider insert() Method
    • Implementing the Content Provider query() Method
    • Implementing the Content Provider update() Method
    • Implementing the Content Provider update() Method
    • Implementing the Content Provider delete() Method
    • Declaring the Content Provider in the Manifest File
    • Modifying the Database Handler
      
      
37. Implementing Video Playback on Android using the VideoView and MediaController Classes
    • Introducing the Android VideoView Class
    • Introducing the Android MediaController Class
    • Testing Video Playback
    • Creating the Video Playback Example
    • Designing VideoPlayer Layout
    • Configuring the VideoView
    • Adding Internet Permission
    • Adding the MediaController to the Video View
    • Setting up the onPreparedListener
      
      
38. Video Recording and Image Capture on the Kindle Fire using Camera Intents
    • Checking for Camera Support
    • Calling the Video Capture Intent
    • Calling the Image Capture Intent
    • Creating an Example Video Recording Project
    • Designing the User Interface Layout
    • Checking for the Camera
    • Launching the Video Capture Intent
    • Handling the Intent Return
    • Testing the Application
      
      
39. Kindle Fire Audio Recording and Playback using MediaPlayer and MediaRecorder
    • Playing Audio
    • Recording Audio and Video using the MediaRecorder Class
    • About the Example Project
    • Creating the AudioApp Project
    • Designing the User Interface
    • Checking for Microphone Availability
    • Performing the Activity Initialization
    • Implementing the recordAudio() Method
    • Implementing the stopRecording() Method
    • Implementing the playAudio() method
    • Configuring Permissions in the Manifest File
    • Testing the Application
      
      
40. Working with the Amazon Maps API on the Kindle Fire
    • Amazon Maps vs. Google Maps
    • The Elements of Amazon Maps
    • Getting Ready to Use Amazon Maps
    • Downloading the Amazon Mobile SDK
    • Adding the Amazon Mobile SDK to an Eclipse Project
    • Obtaining Your Developer Signature
    • Registering the Application in the Amazon Mobile App Distribution Portal
    • Adding Map Support to the AndroidManifest.xml File
    • Enabling Location Based Services on the Kindle Fire Device
    • Registering an Emulator
    • Adjusting the Emulator Location Settings
    • Checking for Map Support
    • Understanding Geocoding and Reverse Geocoding
    • Adding a MapView to an Application
    • Customizing a Map View using the MapController
    • Displaying the User’s Current Location
    • Creating an Itemized Overlay
      
      
41. A Kindle Fire Amazon Maps API Tutorial
    • About the Example Map Application
    • Creating and Preparing the MapExample Project
    • Registering the Application in the Amazon Mobile App Distribution Portal
    • Modifying the Android Manifest File
    • Adding the Map View Activity
    • Adding the MapView Object
    • Designing the User Interface for the MapExampleActivity Class
    • Checking for Maps Support
    • Launching the Intent
    • Updating the Map Location
    • Testing the Application
      
      
42. Marking Android Map Locations using Amazon Map Overlays
    • Creating the Map Overlay Class
    • Adding the Drawable to the Project
    • Adding the Overlay to the MapView
    • Testing the Application
      
      
43. An Overview of the Amazon In-App Purchasing API
    • Understanding the Different Types of In-App Purchase
    • Local and Remote Content
    • The Architecture of the Amazon In-App Purchasing API|The Purchasing Observer
    • The Purchasing Manager
    • The Amazon Client
    • The SDK Tester
    • Defining In-App Purchase Items
    • Preparing a Project to use the In-App Purchasing API
    • Modifying the Manifest File
      
      
44. A Simple Amazon In-App Purchasing Example Application
    • Creating the Example Application
    • Adding the in-app-purchasing Library to the Project
    • Adding the Receiver to the Manifest File
    • Designing the User Interface
    • Creating the Purchasing Observer Class
    • Adding the SKU as a String Resource
    • Displaying the Purchase Item Details
    • Initiating the Purchase
    • Handling the Purchase Response
    • Creating and Installing the SDK Tester Purchase Item File
    • Installing the SDK Tester
    • Testing the Application
    • Simulating Purchase Problems
      
      
45. Integrating Ads with the Amazon Mobile Ads API
    • The Amazon Mobile Ads API
    • Ad Targeting Options
    • Amazon Mobile Ads API – The Rules of Use
    • Downloading and Installing the Amazon Mobile Ads API
    • Providing Tax and Banking Information
    • Preparing a Project to use Amazon Mobile Ads
    • Adding the API JAR File to the Project
    • Obtaining the Application Key
    • Configuring the Manifest File
    • Adding the Amazon Ad Resources
    • Registering the Application Key
    • Writing Java Code to Display an Ad
    • Adding an Ad to the Layout Resource File
    • Setting Ad Targeting Options
    • Enabling Testing and Logging
    • Tracking Events with an AdListener
    • Configuring the Ad Request Timeout
      
      
46. A Kindle Fire Amazon Mobile Ads API Example Application
    • Creating the AdExample Project
    • Adding the amazon-ads Library to the Project
    • Adding the Application to the Amazon Mobile App Portal
    • Configuring the Application Manifest File
    • Modifying the User Interface Layout
    • Implementing the AdListener
    • Modifying the onCreate() Method
    • Testing the Application
      
      
47. Handling Different Kindle Fire Devices and Displays
    • Handling Different Kindle Fire Displays
    • Creating a Layout for each Kindle Fire Display
    • Providing Different Images
    • Checking for Hardware Support
    • Providing Device Specific Application Binaries
      
      
48. Submitting an Application to the Amazon Mobile App Distribution Portal
    • Logging into the Amazon Mobile App Distribution Portal
    • Adding a New App
    • General Information
    • Availability and Pricing
    • Description
    • Images and Multimedia
    • Content Rating
    • Binary Files
    • Submitting the App