You are previewing Beginning Android 3.
O'Reilly logo
Beginning Android 3

Book Description

The vibrant and rich Android development platform, created by Google and the Open Handset Alliance, continues to be a platform in its truest sense, encompassing hundreds of classes beyond the traditional Java classes and open source components that ship with the SDK. Android's continued growth includes support for Flash and Flash Gaming Apps, WIFI tethering, improved performance, WebM or WebMedia integration for HTML 5 based video and other multimedia APIs, Chrome OS (WebOS) integration, and more.

With Beginning Android 3, you'll learn how to develop applications for Android 3 mobile devices using simple examples that are ready to run with your copy of the SDK. Author, Android columnist, developer, and community advocate Mark L. Murphy will show you what you need to know to get started programming Android applications, including how to craft GUIs, use GPS, Multi-touch, Multi-tasking, and access web services.

What you'll learn

  • Discover Android and how to use it to build Java-based mobile applications for a wide range of phones and devices.

  • Create user interfaces using both the Android widget framework and the built-in WebKit-powered Web browser components.

  • Utilize the distinctive capabilities of the Android engine, including location tracking, maps, and Internet access.

  • Use and create Android applications incorporating activities, services, content providers, and broadcast receivers.

  • Support Android 3 and earlier devices, including dealing with multiple Android OS versions, multiple screen sizes, and other device-specific characteristics.

  • Create Flash game and other apps on Android.

  • Build and experience the array of new WebM video and other multimedia APIs for Android and more.

Who this book is for

This book is aimed at people new to mobile development.

Table of Contents

  1. Copyright
  2. About the Author
  3. About the Technical Reviewer
  4. Acknowledgments
  5. Preface
    1. Welcome to the Book!
    2. Prerequisites
    3. Editions of This Book
    4. Source Code and Its License
  6. I. Core Concept
    1. 1. The Big Picture
      1. 1.1. Benefits and Drawbacks of Smartphone Programming
      2. 1.2. What Androids Are Made Of
      3. 1.3. Stuff at Your Disposal
      4. 1.4. The Big Picture...of This Book
    2. 2. How to Get Started
      1. 2.1. Step 1: Set Up Java
        1. 2.1.1. Install the JDK
          1. 2.1.1.1. Alternative Java Compilers
        2. 2.1.2. Learn Java
      2. 2.2. Step 2: Install the Android SDK
        1. 2.2.1. Install the Base Tools
        2. 2.2.2. Install the SDKs and Add-ons
      3. 2.3. Step 3: Install the ADT for Eclipse
      4. 2.4. Step 4: Install Apache Ant
      5. 2.5. Step 5: Set Up the Emulator
      6. 2.6. Step 6: Set Up the Device
        1. 2.6.1. Windows
        2. 2.6.2. Mac OS X and Linux
    3. 3. Your First Android Project
      1. 3.1. Step 1: Create the New Project
        1. 3.1.1. Eclipse
        2. 3.1.2. Command Line
      2. 3.2. Step 2: Build, Install, and Run the Application in Your Emulator or Device
        1. 3.2.1. Eclipse
        2. 3.2.2. Command Line
    4. 4. Examining Your First Project
      1. 4.1. Project Structure
        1. 4.1.1. Root Contents
        2. 4.1.2. The Sweat Off Your Brow
        3. 4.1.3. And Now, the Rest of the Story
        4. 4.1.4. What You Get Out of It
      2. 4.2. Inside Your Manifest
        1. 4.2.1. In the Beginning, There Was the Root, and It Was Good
        2. 4.2.2. An Application for Your Application
    5. 5. A Bit About Eclipse
      1. 5.1. What the ADT Gives You
      2. 5.2. Coping with Eclipse
        1. 5.2.1. How to Import a Non-Eclipse Project
        2. 5.2.2. How to Get to DDMS
        3. 5.2.3. How to Create an Emulator
        4. 5.2.4. How to Run a Project
        5. 5.2.5. How Not to Run Your Project
      3. 5.3. Alternative IDEs
      4. 5.4. IDEs and This Book
    6. 6. Enhancing Your First Project
      1. 6.1. Supporting Multiple Screen Sizes
      2. 6.2. Specifying Versions
  7. II. Activities
    1. 7. Rewriting Your First Project
      1. 7.1. The Activity
      2. 7.2. Dissecting the Activity
      3. 7.3. Building and Running the Activity
    2. 8. Using XML-Based Layouts
      1. 8.1. What Is an XML-Based Layout?
      2. 8.2. Why Use XML-Based Layouts?
      3. 8.3. OK, So What Does It Look Like?
      4. 8.4. What's with the @ Signs?
      5. 8.5. And How Do We Attach These to the Java?
      6. 8.6. The Rest of the Story
    3. 9. Employing Basic Widgets
      1. 9.1. Assigning Labels
      2. 9.2. Button, Button, Who's Got the Button?
      3. 9.3. Fleeting Images
      4. 9.4. Fields of Green...or Other Colors
      5. 9.5. Just Another Box to Check
      6. 9.6. Turn the Radio Up
      7. 9.7. It's Quite a View
        1. 9.7.1. Padding
        2. 9.7.2. Other Useful Properties
        3. 9.7.3. Useful Methods
        4. 9.7.4. Colors
    4. 10. Working with Containers
      1. 10.1. Thinking Linearly
        1. 10.1.1. LinearLayout Concepts and Properties
          1. 10.1.1.1. Orientation
          2. 10.1.1.2. Fill Model
          3. 10.1.1.3. Weight
          4. 10.1.1.4. Gravity
          5. 10.1.1.5. Margins
        2. 10.1.2. LinearLayout Example
        3. 10.1.3. The Box Model
      2. 10.2. All Things Are Relative
        1. 10.2.1. RelativeLayout Concepts and Properties
          1. 10.2.1.1. Positions Relative to Container
          2. 10.2.1.2. Relative Notation in Properties
          3. 10.2.1.3. Positions Relative to Other Widgets
          4. 10.2.1.4. Order of Evaluation
        2. 10.2.2. RelativeLayout Example
        3. 10.2.3. Overlap
      3. 10.3. Tabula Rasa
        1. 10.3.1. TableLayout Concepts and Properties
          1. 10.3.1.1. Putting Cells in Rows
          2. 10.3.1.2. Non-Row Children of TableLayout
          3. 10.3.1.3. Stretch, Shrink, and Collapse
        2. 10.3.2. TableLayout Example
      4. 10.4. Scrollwork
    5. 11. The Input Method Framework
      1. 11.1. Keyboards, Hard and Soft
      2. 11.2. Tailored to Your Needs
      3. 11.3. Tell Android Where It Can Go
      4. 11.4. Fitting In
      5. 11.5. Jane, Stop This Crazy Thing!
    6. 12. Using Selection Widgets
      1. 12.1. Adapting to the Circumstances
        1. 12.1.1. Using ArrayAdapter
      2. 12.2. Lists of Naughty and Nice
        1. 12.2.1. Selection Modes
      3. 12.3. Spin Control
      4. 12.4. Grid Your Lions (or Something Like That...)
      5. 12.5. Fields: Now with 35% Less Typing!
      6. 12.6. Galleries, Give or Take the Art
    7. 13. Getting Fancy with Lists
      1. 13.1. Getting to First Base
      2. 13.2. A Dynamic Presentation
      3. 13.3. Inflating Rows Ourselves
        1. 13.3.1. A Sidebar About Inflation
        2. 13.3.2. And Now, Back to Our Story
      4. 13.4. Better. Stronger. Faster.
        1. 13.4.1. Using convertView
        2. 13.4.2. Using the Holder Pattern
      5. 13.5. Interactive Rows
    8. 14. Still More Widgets and Containers
      1. 14.1. Pick and Choose
      2. 14.2. Time Keeps Flowing Like a River
      3. 14.3. Seeking Resolution
      4. 14.4. Putting It on My Tab
        1. 14.4.1. The Pieces
        2. 14.4.2. Wiring It Together
        3. 14.4.3. Adding Them Up
      5. 14.5. Flipping Them Off
      6. 14.6. Getting in Somebody's Drawer
      7. 14.7. Other Good Stuff
    9. 15. Embedding the WebKit Browser
      1. 15.1. A Browser, Writ Small
      2. 15.2. Loading It Up
      3. 15.3. Navigating the Waters
      4. 15.4. Entertaining the Client
      5. 15.5. Settings, Preferences, and Options (Oh, My!)
    10. 16. Applying Menus
      1. 16.1. Flavors of Menu
      2. 16.2. Menus of Options
      3. 16.3. Menus in Context
      4. 16.4. Taking a Peek
      5. 16.5. Yet More Inflation
        1. 16.5.1. Menu XML Structure
        2. 16.5.2. Menu Options and XML
        3. 16.5.3. Inflating the Menu
      6. 16.6. In the Land of Menus and Honey
    11. 17. Showing Pop-Up Messages
      1. 17.1. Raising Toasts
      2. 17.2. Alert! Alert!
      3. 17.3. Checking Them Out
    12. 18. Handling Activity Lifecycle Events
      1. 18.1. Schroedinger's Activity
      2. 18.2. Life, Death, and Your Activity
        1. 18.2.1. onCreate() and onDestroy()
        2. 18.2.2. onStart(), onRestart(), and onStop()
        3. 18.2.3. onPause() and onResume()
      3. 18.3. The Grace of State
    13. 19. Handling Rotation
      1. 19.1. A Philosophy of Destruction
      2. 19.2. It's All the Same, Just Different
        1. 19.2.1. Picking and Viewing a Contact
        2. 19.2.2. Saving Your State
      3. 19.3. Now with More Savings!
      4. 19.4. DIY Rotation
        1. 19.4.1. ...But Google Does Not Recommend This
      5. 19.5. Forcing the Issue
      6. 19.6. Making Sense of It All
    14. 20. Dealing with Threads
      1. 20.1. The Main Application Thread
      2. 20.2. Making Progress with ProgressBars
      3. 20.3. Getting Through the Handlers
        1. 20.3.1. Messages
        2. 20.3.2. Runnables
      4. 20.4. Where Oh Where Has My UI Thread Gone?
      5. 20.5. Asyncing Feeling
        1. 20.5.1. The Theory
        2. 20.5.2. AsyncTask, Generics, and Varargs
        3. 20.5.3. The Stages of AsyncTask
        4. 20.5.4. A Sample Task
          1. 20.5.4.1. The AddStringTask Declaration
          2. 20.5.4.2. The doInBackground() Method
          3. 20.5.4.3. The onProgressUpdate() Method
          4. 20.5.4.4. The onPostExecute() Method
          5. 20.5.4.5. The Activity
          6. 20.5.4.6. The Results
      6. 20.6. Threads and Rotation
        1. 20.6.1. Manual Activity Association
        2. 20.6.2. Flow of Events
        3. 20.6.3. Why This Works
      7. 20.7. And Now, the Caveats
    15. 21. Creating Intent Filters
      1. 21.1. What's Your Intent?
        1. 21.1.1. Pieces of Intents
        2. 21.1.2. Intent Routing
      2. 21.2. Stating Your Intent(ions)
      3. 21.3. Narrow Receivers
      4. 21.4. The Pause Caveat
    16. 22. Launching Activities and Subactivities
      1. 22.1. Peers and Subs
      2. 22.2. Start 'Em Up
        1. 22.2.1. Make an Intent
        2. 22.2.2. Make the Call
      3. 22.3. Tabbed Browsing, Sort Of
    17. 23. Working with Resources
      1. 23.1. The Resource Lineup
      2. 23.2. String Theory
        1. 23.2.1. Plain Strings
        2. 23.2.2. String Formats
        3. 23.2.3. Styled Text
        4. 23.2.4. Styled Text and Formats
      3. 23.3. Got the Picture?
      4. 23.4. XML: The Resource Way
      5. 23.5. Miscellaneous Values
        1. 23.5.1. Dimensions
        2. 23.5.2. Colors
        3. 23.5.3. Arrays
      6. 23.6. Different Strokes for Different Folks
      7. 23.7. RTL Languages: Going Both Ways
    18. 24. Defining and Using Styles
      1. 24.1. Styles: DIY DRY
      2. 24.2. Elements of Style
        1. 24.2.1. Where to Apply a Style
        2. 24.2.2. The Available Attributes
        3. 24.2.3. Inheriting a Style
        4. 24.2.4. The Possible Values
      3. 24.3. Themes: A Style by Any Other Name...
    19. 25. Handling Multiple Screen Sizes
      1. 25.1. Taking the Default
      2. 25.2. Whole in One
        1. 25.2.1. Think About Rules, Not Positions
        2. 25.2.2. Consider Physical Dimensions
        3. 25.2.3. Avoid "Real" Pixels
        4. 25.2.4. Choose Scalable Drawables
      3. 25.3. Tailor-Made, Just for You (and You, and You, and...)
        1. 25.3.1. Adding the <supports-screens> Element
        2. 25.3.2. Resources and Resource Sets
          1. 25.3.2.1. Default Scaling
          2. 25.3.2.2. Density-Based Sets
          3. 25.3.2.3. Size-Based Sets
          4. 25.3.2.4. Version-Based Sets
        3. 25.3.3. Finding Your Size
      4. 25.4. Ain't Nothing Like the Real Thing
        1. 25.4.1. Density Differs
        2. 25.4.2. Adjusting the Density
      5. 25.5. Ruthlessly Exploiting the Situation
        1. 25.5.1. Replace Menus with Buttons
        2. 25.5.2. Replace Tabs with a Simple Activity
        3. 25.5.3. Consolidate Multiple Activities
      6. 25.6. Example: EU4You
        1. 25.6.1. The First Cut
        2. 25.6.2. Fixing the Fonts
        3. 25.6.3. Fixing the Icons
        4. 25.6.4. Using the Space
        5. 25.6.5. What If It Is Not a Browser?
  8. III. Honeycomb and Tablets
    1. 26. Introducing the Honeycomb UI
      1. 26.1. Why Honeycomb?
      2. 26.2. What the User Sees
      3. 26.3. The Holographic Theme
      4. 26.4. Dealing with the Rest of the Devices
    2. 27. Using the Action Bar
      1. 27.1. Enabling the Action Bar
      2. 27.2. Promoting Menu Items to the Action Bar
      3. 27.3. Responding to the Logo
      4. 27.4. Adding Custom Views to the Action Bar
        1. 27.4.1. Defining the Layout
        2. 27.4.2. Putting the Layout in the Menu
        3. 27.4.3. Getting Control of User Input
      5. 27.5. Don't Forget the Phones!
    3. 28. Fragments
      1. 28.1. Introducing Fragments
        1. 28.1.1. The Problem Addressed by Fragments
        2. 28.1.2. The Fragments Solution
        3. 28.1.3. The Android Compatibility Library
      2. 28.2. Creating Fragment Classes
        1. 28.2.1. General Fragments
        2. 28.2.2. ListFragment
          1. 28.2.2.1. Persistent Highlight
        3. 28.2.3. Other Fragment Base Classes
      3. 28.3. Fragments, Layouts, Activities, and Multiple Screen Sizes
        1. 28.3.1. EU4You
          1. 28.3.1.1. The Layout
          2. 28.3.1.2. The Other Layout
          3. 28.3.1.3. The Listener Interface
          4. 28.3.1.4. The Activity
        2. 28.3.2. DetailsActivity
          1. 28.3.2.1. The Layout
          2. 28.3.2.2. The Activity
      4. 28.4. Fragments and Configuration Changes
      5. 28.5. Designing for Fragments
    4. 29. Handling Platform Changes
      1. 29.1. Things That Make You Go Boom
        1. 29.1.1. View Hierarchy
        2. 29.1.2. Changing Resources
      2. 29.2. Handling API Changes
        1. 29.2.1. Minimum, Maximum, Target, and Build Versions
          1. 29.2.1.1. Targets vs. SDK Versions vs. OS Versions
          2. 29.2.1.2. Minimum SDK Version
          3. 29.2.1.3. Target SDK Version
          4. 29.2.1.4. Maximum SDK Version
        2. 29.2.2. Detecting the Version
        3. 29.2.3. Wrapping the API
          1. 29.2.3.1. Detecting Classes
          2. 29.2.3.2. Reflection
          3. 29.2.3.3. Conditional Class Loading
      3. 29.3. Patterns for Honeycomb
        1. 29.3.1. The Action Bar
          1. 29.3.1.1. Checking the API Level
          2. 29.3.1.2. Isolating the Honeycomb Code
        2. 29.3.2. Writing Tablet-Only Apps
    5. 30. Accessing Files
      1. 30.1. You and the Horse You Rode in On
      2. 30.2. Readin' 'n Writin'
      3. 30.3. External Storage: Giant Economy-Size Space
        1. 30.3.1. Where to Write
        2. 30.3.2. When to Write
      4. 30.4. StrictMode: Avoiding Janky Code
        1. 30.4.1. Setting Up StrictMode
        2. 30.4.2. Seeing StrictMode in Action
        3. 30.4.3. Development Only, Please!
        4. 30.4.4. Conditionally Being Strict
      5. 30.5. Linux File Systems: You Sync, You Win
  9. IV. Data Stores, Network Services, and APIs
    1. 31. Using Preferences
      1. 31.1. Getting What You Want
      2. 31.2. Stating Your Preference
      3. 31.3. Introducing PreferenceActivity
      4. 31.4. Letting Users Have Their Say
      5. 31.5. Adding a Wee Bit o' Structure
      6. 31.6. The Kind of Pop-Ups You Like
      7. 31.7. Preferences via Fragments
        1. 31.7.1. The Honeycomb Way
          1. 31.7.1.1. Preference Headers
          2. 31.7.1.2. PreferenceFragment and StockPreferenceFragment
          3. 31.7.1.3. Avoiding Nested PreferenceScreen Elements
          4. 31.7.1.4. Intents for Headers or Preferences
        2. 31.7.2. Adding Backward Compatibility
    2. 32. Managing and Accessing Local Databases
      1. 32.1. A Quick SQLite Primer
      2. 32.2. Start at the Beginning
      3. 32.3. Setting the Table
      4. 32.4. Makin' Data
      5. 32.5. What Goes Around, Comes Around
        1. 32.5.1. Raw Queries
        2. 32.5.2. Regular Queries
        3. 32.5.3. Using Cursors
        4. 32.5.4. Custom CursorAdapters
        5. 32.5.5. Making Your Own Cursors
      6. 32.6. Flash: Sounds Faster Than It Is
      7. 32.7. Data, Data, Everywhere
    3. 33. Leveraging Java Libraries
      1. 33.1. Ants and JARs
      2. 33.2. The Outer Limits
      3. 33.3. Following the Script
      4. 33.4. Reviewing the Script
    4. 34. Communicating via the Internet
      1. 34.1. REST and Relaxation
        1. 34.1.1. HTTP Operations via Apache HttpClient
        2. 34.1.2. Parsing Responses
        3. 34.1.3. Stuff to Consider
        4. 34.1.4. AndroidHttpClient
      2. 34.2. Leveraging Internet-Aware Android Components
        1. 34.2.1. Downloading Files
          1. 34.2.1.1. The Permissions
          2. 34.2.1.2. The Layout
          3. 34.2.1.3. Requesting the Download
          4. 34.2.1.4. Keeping Track of Download Status
          5. 34.2.1.5. What the User Sees
          6. 34.2.1.6. Limitations
      3. 34.3. Continuing Our Escape from Janky Code
  10. V. Services
    1. 35. Services: The Theory
      1. 35.1. Why Services?
      2. 35.2. Setting Up a Service
        1. 35.2.1. Service Class
        2. 35.2.2. Lifecycle Methods
        3. 35.2.3. Manifest Entry
      3. 35.3. Communicating to Services
        1. 35.3.1. Sending Commands with startService()
        2. 35.3.2. Binding with bindService()
      4. 35.4. Communicating from Services
        1. 35.4.1. Callback/Listener Objects
        2. 35.4.2. Broadcast Intents
        3. 35.4.3. Pending Results
        4. 35.4.4. Messenger
        5. 35.4.5. Notifications
    2. 36. Basic Service Patterns
      1. 36.1. The Downloader
        1. 36.1.1. The Design
        2. 36.1.2. The Service Implementation
        3. 36.1.3. Using the Service
      2. 36.2. The Music Player
        1. 36.2.1. The Design
        2. 36.2.2. The Service Implementation
        3. 36.2.3. Using the Service
      3. 36.3. The Web Service Interface
        1. 36.3.1. The Design
        2. 36.3.2. The Rotation Challenge
        3. 36.3.3. The Service Implementation
          1. 36.3.3.1. The Forecast
          2. 36.3.3.2. The Interface
          3. 36.3.3.3. The Binder
          4. 36.3.3.4. The Service
        4. 36.3.4. Using the Service
          1. 36.3.4.1. Managing the State
          2. 36.3.4.2. Time to Unbind
    3. 37. Alerting Users via Notifications
      1. 37.1. Notification Configuration
        1. 37.1.1. Hardware Notifications
        2. 37.1.2. Icons
      2. 37.2. Notifications in Action
      3. 37.3. Staying in the Foreground
        1. 37.3.1. FakePlayer, Redux
      4. 37.4. Notifications and Honeycomb
  11. VI. Other Android Capabilities
    1. 38. Requesting and Requiring Permissions
      1. 38.1. Mother, May I?
      2. 38.2. Halt! Who Goes There?
        1. 38.2.1. Enforcing Permissions via the Manifest
        2. 38.2.2. Enforcing Permissions Elsewhere
      3. 38.3. May I See Your Documents?
      4. 38.4. New Permissions in Old Applications
      5. 38.5. Permissions: Up Front or Not at All
    2. 39. Accessing Location-Based Services
      1. 39.1. Location Providers: They Know Where You're Hiding
      2. 39.2. Finding Yourself
      3. 39.3. On the Move
      4. 39.4. Are We There Yet? Are We There Yet?
      5. 39.5. Testing...Testing...
    3. 40. Mapping with MapView and MapActivity
      1. 40.1. Terms, Not of Endearment
      2. 40.2. Piling On
      3. 40.3. The Key to It All
      4. 40.4. The Bare Bones
        1. 40.4.1. Optional Maps
      5. 40.5. Exercising Your Control
        1. 40.5.1. Zoom
        2. 40.5.2. Center
      6. 40.6. Layers Upon Layers
        1. 40.6.1. Overlay Classes
        2. 40.6.2. Drawing the ItemizedOverlay
        3. 40.6.3. Handling Screen Taps
      7. 40.7. My, Myself, and MyLocationOverlay
      8. 40.8. Rugged Terrain
      9. 40.9. Maps and Fragments
        1. 40.9.1. Limit Yourself to Android 3.0
        2. 40.9.2. Use onCreateView() and onActivityCreated()
        3. 40.9.3. Host the Fragment in a MapActivity
    4. 41. Handling Telephone Calls
      1. 41.1. Report to the Manager
      2. 41.2. You Make the Call!
      3. 41.3. No, Really, You Make the Call!
    5. 42. Fonts
      1. 42.1. Love the One You're With
      2. 42.2. Additional Fonts
      3. 42.3. Here a Glyph, There a Glyph
    6. 43. More Development Tools
      1. 43.1. Hierarchy Viewer: How Deep Is Your Code?
      2. 43.2. DDMS: Under Android's Hood
        1. 43.2.1. Logging
        2. 43.2.2. File Push and Pull
        3. 43.2.3. Screenshots
        4. 43.2.4. Location Updates
        5. 43.2.5. Placing Calls and Messages
        6. 43.2.6. Memory Management
      3. 43.3. adb: Like DDMS, with More Typing
  12. VII. Alternative Application Environments
    1. 44. The Role of Alternative Environments
      1. 44.1. In the Beginning, There Was Java...
      2. 44.2. ...And It Was OK
      3. 44.3. Bucking the Trend
      4. 44.4. Support, Structure
      5. 44.5. Caveat Developer
    2. 45. HTML5
      1. 45.1. Offline Applications
        1. 45.1.1. What Does It Mean?
        2. 45.1.2. How Do You Use It?
          1. 45.1.2.1. About the Sample App
          2. 45.1.2.2. "Installing" Checklist on Your Android Device
          3. 45.1.2.3. Examining the HTML
          4. 45.1.2.4. Examining the Manifest
      2. 45.2. Web Storage
        1. 45.2.1. What Does It Mean?
        2. 45.2.2. How Do You Use It?
        3. 45.2.3. Web SQL Database
      3. 45.3. Going to Production
        1. 45.3.1. Testing
        2. 45.3.2. Signing and Distribution
        3. 45.3.3. Updates
      4. 45.4. Issues You May Encounter
        1. 45.4.1. Android Device Versions
        2. 45.4.2. Screen Sizes and Densities
        3. 45.4.3. Limited Platform Integration
        4. 45.4.4. Performance and Battery
        5. 45.4.5. Look and Feel
        6. 45.4.6. Distribution
      5. 45.5. HTML5 and Alternative Android Browsers
      6. 45.6. HTML5: The Baseline
    3. 46. PhoneGap
      1. 46.1. What Is PhoneGap?
        1. 46.1.1. What Do You Write In?
        2. 46.1.2. What Features Do You Get?
        3. 46.1.3. What Do Apps Look Like?
        4. 46.1.4. How Does Distribution Work?
        5. 46.1.5. What About Other Platforms?
      2. 46.2. Using PhoneGap
        1. 46.2.1. Installation
        2. 46.2.2. Creating and Installing Your Project
        3. 46.2.3. PhoneGap Build
      3. 46.3. PhoneGap and the Checklist Sample
        1. 46.3.1. Sticking to the Standards
        2. 46.3.2. Adding PhoneGap APIs
          1. 46.3.2.1. Set Up Device-Ready Event Handler
          2. 46.3.2.2. Use What PhoneGap Gives You
      4. 46.4. Issues You May Encounter
        1. 46.4.1. Security
        2. 46.4.2. Screen Sizes and Densities
        3. 46.4.3. Look and Feel
      5. 46.5. For More Information
    4. 47. Other Alternative Environments
      1. 47.1. Rhodes
      2. 47.2. Flash, Flex, and AIR
      3. 47.3. JRuby and Ruboto
      4. 47.4. Mono for Android
      5. 47.5. App Inventor
      6. 47.6. Titanium Mobile
      7. 47.7. Other JVM Compiled Languages
  13. VIII. The Ever-Evolving Android
    1. 48. Dealing with Devices
      1. 48.1. This App Contains Explicit Instructions
        1. 48.1.1. Explicit Feature Requests
        2. 48.1.2. Implied Feature Requests
      2. 48.2. A Guaranteed Market
      3. 48.3. Other Stuff That Varies
      4. 48.4. Bugs, Bugs, Bugs
      5. 48.5. Device Testing
    2. 49. Where Do We Go from Here?
      1. 49.1. Questions, Sometimes with Answers
      2. 49.2. Heading to the Source
      3. 49.3. Getting Your News Fix