	Table of Contents	Next
		An Overview and History of the Kindle Fire

<google>BUY_KINDLE_FIRE</google>

Introduction to Kindle Fire App Development Essentials
- About Kindle Fire App Development Essentials
- Downloading the Code Samples
- Feedback
- Errata
An Overview of the Kindle Fire
- Kindle Fire Operating System
- Kindle Fire, the Cloud and Pricing
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
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
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
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
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
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
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
Handling Android Activity State Changes
- The Activity Class
- Dynamic State vs. Persistent State
- The Android Activity Lifecycle Methods
- Activity Lifetimes
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
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
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
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
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)
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
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
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
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
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
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
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
An Overview of Android Intents
- An Overview of Intents
- Explicit Intents
- Returning Data from an Activity
- Implicit Intents
- Using Intent Filters
- Checking Intent Availability
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
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
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
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
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
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
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
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
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
An Android TableLayout and TableRow Tutorial
- The TableLayout and TableRow Layout Views
- Creating the Database Project
- Designing the User Interface Layout
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
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
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
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
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
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
Working with the Amazon Maps API on the Kindle Fire
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
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
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
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
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
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
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
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

<google>BUY_KINDLE_FIRE</google>

	Table of Contents	Next
		An Overview and History of the Kindle Fire

Kindle Fire Development Essentials

Table of Contents

Techotopia