book

Beginning Android 3

by Mark Murphy

July 2011

Beginner

612 pages

12h 12m

English

Apress

Read now

Unlock full access

Welcome to the Book!PrerequisitesEditions of This BookSource Code and Its License
1.1. Benefits and Drawbacks of Smartphone Programming1.2. What Androids Are Made Of1.3. Stuff at Your Disposal1.4. The Big Picture...of This Book
2.1. Step 1: Set Up Java2.1.1. Install the JDK2.1.1.1. Alternative Java Compilers2.1.2. Learn Java2.2. Step 2: Install the Android SDK2.2.1. Install the Base Tools2.2.2. Install the SDKs and Add-ons2.3. Step 3: Install the ADT for Eclipse2.4. Step 4: Install Apache Ant2.5. Step 5: Set Up the Emulator2.6. Step 6: Set Up the Device2.6.1. Windows2.6.2. Mac OS X and Linux
3.1. Step 1: Create the New Project3.1.1. Eclipse3.1.2. Command Line3.2. Step 2: Build, Install, and Run the Application in Your Emulator or Device3.2.1. Eclipse3.2.2. Command Line
4.1. Project Structure4.1.1. Root Contents4.1.2. The Sweat Off Your Brow4.1.3. And Now, the Rest of the Story4.1.4. What You Get Out of It4.2. Inside Your Manifest4.2.1. In the Beginning, There Was the Root, and It Was Good4.2.2. An Application for Your Application

5.1. What the ADT Gives You5.2. Coping with Eclipse5.2.1. How to Import a Non-Eclipse Project5.2.2. How to Get to DDMS5.2.3. How to Create an Emulator5.2.4. How to Run a Project5.2.5. How Not to Run Your Project5.3. Alternative IDEs5.4. IDEs and This Book
6.1. Supporting Multiple Screen Sizes6.2. Specifying Versions
7.1. The Activity7.2. Dissecting the Activity7.3. Building and Running the Activity
8.1. What Is an XML-Based Layout?8.2. Why Use XML-Based Layouts?8.3. OK, So What Does It Look Like?8.4. What's with the @ Signs?8.5. And How Do We Attach These to the Java?8.6. The Rest of the Story
9.1. Assigning Labels9.2. Button, Button, Who's Got the Button?9.3. Fleeting Images9.4. Fields of Green...or Other Colors9.5. Just Another Box to Check9.6. Turn the Radio Up9.7. It's Quite a View9.7.1. Padding9.7.2. Other Useful Properties9.7.3. Useful Methods9.7.4. Colors
10.1. Thinking Linearly10.1.1. LinearLayout Concepts and Properties10.1.1.1. Orientation10.1.1.2. Fill Model10.1.1.3. Weight10.1.1.4. Gravity10.1.1.5. Margins10.1.2. LinearLayout Example10.1.3. The Box Model10.2. All Things Are Relative10.2.1. RelativeLayout Concepts and Properties10.2.1.1. Positions Relative to Container10.2.1.2. Relative Notation in Properties10.2.1.3. Positions Relative to Other Widgets10.2.1.4. Order of Evaluation10.2.2. RelativeLayout Example10.2.3. Overlap10.3. Tabula Rasa10.3.1. TableLayout Concepts and Properties10.3.1.1. Putting Cells in Rows10.3.1.2. Non-Row Children of TableLayout10.3.1.3. Stretch, Shrink, and Collapse10.3.2. TableLayout Example10.4. Scrollwork
11.1. Keyboards, Hard and Soft11.2. Tailored to Your Needs11.3. Tell Android Where It Can Go11.4. Fitting In11.5. Jane, Stop This Crazy Thing!
12.1. Adapting to the Circumstances12.1.1. Using ArrayAdapter12.2. Lists of Naughty and Nice12.2.1. Selection Modes12.3. Spin Control12.4. Grid Your Lions (or Something Like That...)12.5. Fields: Now with 35% Less Typing!12.6. Galleries, Give or Take the Art
13.1. Getting to First Base13.2. A Dynamic Presentation13.3. Inflating Rows Ourselves13.3.1. A Sidebar About Inflation13.3.2. And Now, Back to Our Story13.4. Better. Stronger. Faster.13.4.1. Using convertView13.4.2. Using the Holder Pattern13.5. Interactive Rows
14.1. Pick and Choose14.2. Time Keeps Flowing Like a River14.3. Seeking Resolution14.4. Putting It on My Tab14.4.1. The Pieces14.4.2. Wiring It Together14.4.3. Adding Them Up14.5. Flipping Them Off14.6. Getting in Somebody's Drawer14.7. Other Good Stuff
15.1. A Browser, Writ Small15.2. Loading It Up15.3. Navigating the Waters15.4. Entertaining the Client15.5. Settings, Preferences, and Options (Oh, My!)
16.1. Flavors of Menu16.2. Menus of Options16.3. Menus in Context16.4. Taking a Peek16.5. Yet More Inflation16.5.1. Menu XML Structure16.5.2. Menu Options and XML16.5.3. Inflating the Menu16.6. In the Land of Menus and Honey
17.1. Raising Toasts17.2. Alert! Alert!17.3. Checking Them Out
18.1. Schroedinger's Activity18.2. Life, Death, and Your Activity18.2.1. onCreate() and onDestroy()18.2.2. onStart(), onRestart(), and onStop()18.2.3. onPause() and onResume()18.3. The Grace of State
19.1. A Philosophy of Destruction19.2. It's All the Same, Just Different19.2.1. Picking and Viewing a Contact19.2.2. Saving Your State19.3. Now with More Savings!19.4. DIY Rotation19.4.1. ...But Google Does Not Recommend This19.5. Forcing the Issue19.6. Making Sense of It All
20.1. The Main Application Thread20.2. Making Progress with ProgressBars20.3. Getting Through the Handlers20.3.1. Messages20.3.2. Runnables20.4. Where Oh Where Has My UI Thread Gone?20.5. Asyncing Feeling20.5.1. The Theory20.5.2. AsyncTask, Generics, and Varargs20.5.3. The Stages of AsyncTask20.5.4. A Sample Task20.5.4.1. The AddStringTask Declaration20.5.4.2. The doInBackground() Method20.5.4.3. The onProgressUpdate() Method20.5.4.4. The onPostExecute() Method20.5.4.5. The Activity20.5.4.6. The Results20.6. Threads and Rotation20.6.1. Manual Activity Association20.6.2. Flow of Events20.6.3. Why This Works20.7. And Now, the Caveats
21.1. What's Your Intent?21.1.1. Pieces of Intents21.1.2. Intent Routing21.2. Stating Your Intent(ions)21.3. Narrow Receivers21.4. The Pause Caveat
22.1. Peers and Subs22.2. Start 'Em Up22.2.1. Make an Intent22.2.2. Make the Call22.3. Tabbed Browsing, Sort Of
23.1. The Resource Lineup23.2. String Theory23.2.1. Plain Strings23.2.2. String Formats23.2.3. Styled Text23.2.4. Styled Text and Formats23.3. Got the Picture?23.4. XML: The Resource Way23.5. Miscellaneous Values23.5.1. Dimensions23.5.2. Colors23.5.3. Arrays23.6. Different Strokes for Different Folks23.7. RTL Languages: Going Both Ways
24.1. Styles: DIY DRY24.2. Elements of Style24.2.1. Where to Apply a Style24.2.2. The Available Attributes24.2.3. Inheriting a Style24.2.4. The Possible Values24.3. Themes: A Style by Any Other Name...
25.1. Taking the Default25.2. Whole in One25.2.1. Think About Rules, Not Positions25.2.2. Consider Physical Dimensions25.2.3. Avoid "Real" Pixels25.2.4. Choose Scalable Drawables25.3. Tailor-Made, Just for You (and You, and You, and...)25.3.1. Adding the <supports-screens> Element25.3.2. Resources and Resource Sets25.3.2.1. Default Scaling25.3.2.2. Density-Based Sets25.3.2.3. Size-Based Sets25.3.2.4. Version-Based Sets25.3.3. Finding Your Size25.4. Ain't Nothing Like the Real Thing25.4.1. Density Differs25.4.2. Adjusting the Density25.5. Ruthlessly Exploiting the Situation25.5.1. Replace Menus with Buttons25.5.2. Replace Tabs with a Simple Activity25.5.3. Consolidate Multiple Activities25.6. Example: EU4You25.6.1. The First Cut25.6.2. Fixing the Fonts25.6.3. Fixing the Icons25.6.4. Using the Space25.6.5. What If It Is Not a Browser?
26.1. Why Honeycomb?26.2. What the User Sees26.3. The Holographic Theme26.4. Dealing with the Rest of the Devices
27.1. Enabling the Action Bar27.2. Promoting Menu Items to the Action Bar27.3. Responding to the Logo27.4. Adding Custom Views to the Action Bar27.4.1. Defining the Layout27.4.2. Putting the Layout in the Menu27.4.3. Getting Control of User Input27.5. Don't Forget the Phones!
28.1. Introducing Fragments28.1.1. The Problem Addressed by Fragments28.1.2. The Fragments Solution28.1.3. The Android Compatibility Library28.2. Creating Fragment Classes28.2.1. General Fragments28.2.2. ListFragment28.2.2.1. Persistent Highlight28.2.3. Other Fragment Base Classes28.3. Fragments, Layouts, Activities, and Multiple Screen Sizes28.3.1. EU4You28.3.1.1. The Layout28.3.1.2. The Other Layout28.3.1.3. The Listener Interface28.3.1.4. The Activity28.3.2. DetailsActivity28.3.2.1. The Layout28.3.2.2. The Activity28.4. Fragments and Configuration Changes28.5. Designing for Fragments
29.1. Things That Make You Go Boom29.1.1. View Hierarchy29.1.2. Changing Resources29.2. Handling API Changes29.2.1. Minimum, Maximum, Target, and Build Versions29.2.1.1. Targets vs. SDK Versions vs. OS Versions29.2.1.2. Minimum SDK Version29.2.1.3. Target SDK Version29.2.1.4. Maximum SDK Version29.2.2. Detecting the Version29.2.3. Wrapping the API29.2.3.1. Detecting Classes29.2.3.2. Reflection29.2.3.3. Conditional Class Loading29.3. Patterns for Honeycomb29.3.1. The Action Bar29.3.1.1. Checking the API Level29.3.1.2. Isolating the Honeycomb Code29.3.2. Writing Tablet-Only Apps
30.1. You and the Horse You Rode in On30.2. Readin' 'n Writin'30.3. External Storage: Giant Economy-Size Space30.3.1. Where to Write30.3.2. When to Write30.4. StrictMode: Avoiding Janky Code30.4.1. Setting Up StrictMode30.4.2. Seeing StrictMode in Action30.4.3. Development Only, Please!30.4.4. Conditionally Being Strict30.5. Linux File Systems: You Sync, You Win
31.1. Getting What You Want31.2. Stating Your Preference31.3. Introducing PreferenceActivity31.4. Letting Users Have Their Say31.5. Adding a Wee Bit o' Structure31.6. The Kind of Pop-Ups You Like31.7. Preferences via Fragments31.7.1. The Honeycomb Way31.7.1.1. Preference Headers31.7.1.2. PreferenceFragment and StockPreferenceFragment31.7.1.3. Avoiding Nested PreferenceScreen Elements31.7.1.4. Intents for Headers or Preferences31.7.2. Adding Backward Compatibility
32.1. A Quick SQLite Primer32.2. Start at the Beginning32.3. Setting the Table32.4. Makin' Data32.5. What Goes Around, Comes Around32.5.1. Raw Queries32.5.2. Regular Queries32.5.3. Using Cursors32.5.4. Custom CursorAdapters32.5.5. Making Your Own Cursors32.6. Flash: Sounds Faster Than It Is32.7. Data, Data, Everywhere
33.1. Ants and JARs33.2. The Outer Limits33.3. Following the Script33.4. Reviewing the Script
34.1. REST and Relaxation34.1.1. HTTP Operations via Apache HttpClient34.1.2. Parsing Responses34.1.3. Stuff to Consider34.1.4. AndroidHttpClient34.2. Leveraging Internet-Aware Android Components34.2.1. Downloading Files34.2.1.1. The Permissions34.2.1.2. The Layout34.2.1.3. Requesting the Download34.2.1.4. Keeping Track of Download Status34.2.1.5. What the User Sees34.2.1.6. Limitations34.3. Continuing Our Escape from Janky Code
35.1. Why Services?35.2. Setting Up a Service35.2.1. Service Class35.2.2. Lifecycle Methods35.2.3. Manifest Entry35.3. Communicating to Services35.3.1. Sending Commands with startService()35.3.2. Binding with bindService()35.4. Communicating from Services35.4.1. Callback/Listener Objects35.4.2. Broadcast Intents35.4.3. Pending Results35.4.4. Messenger35.4.5. Notifications
36.1. The Downloader36.1.1. The Design36.1.2. The Service Implementation36.1.3. Using the Service36.2. The Music Player36.2.1. The Design36.2.2. The Service Implementation36.2.3. Using the Service36.3. The Web Service Interface36.3.1. The Design36.3.2. The Rotation Challenge36.3.3. The Service Implementation36.3.3.1. The Forecast36.3.3.2. The Interface36.3.3.3. The Binder36.3.3.4. The Service36.3.4. Using the Service36.3.4.1. Managing the State36.3.4.2. Time to Unbind
37.1. Notification Configuration37.1.1. Hardware Notifications37.1.2. Icons37.2. Notifications in Action37.3. Staying in the Foreground37.3.1. FakePlayer, Redux37.4. Notifications and Honeycomb
38.1. Mother, May I?38.2. Halt! Who Goes There?38.2.1. Enforcing Permissions via the Manifest38.2.2. Enforcing Permissions Elsewhere38.3. May I See Your Documents?38.4. New Permissions in Old Applications38.5. Permissions: Up Front or Not at All
39.1. Location Providers: They Know Where You're Hiding39.2. Finding Yourself39.3. On the Move39.4. Are We There Yet? Are We There Yet?39.5. Testing...Testing...
40.1. Terms, Not of Endearment40.2. Piling On40.3. The Key to It All40.4. The Bare Bones40.4.1. Optional Maps40.5. Exercising Your Control40.5.1. Zoom40.5.2. Center40.6. Layers Upon Layers40.6.1. Overlay Classes40.6.2. Drawing the ItemizedOverlay40.6.3. Handling Screen Taps40.7. My, Myself, and MyLocationOverlay40.8. Rugged Terrain40.9. Maps and Fragments40.9.1. Limit Yourself to Android 3.040.9.2. Use onCreateView() and onActivityCreated()40.9.3. Host the Fragment in a MapActivity
41.1. Report to the Manager41.2. You Make the Call!41.3. No, Really, You Make the Call!
42.1. Love the One You're With42.2. Additional Fonts42.3. Here a Glyph, There a Glyph
43.1. Hierarchy Viewer: How Deep Is Your Code?43.2. DDMS: Under Android's Hood43.2.1. Logging43.2.2. File Push and Pull43.2.3. Screenshots43.2.4. Location Updates43.2.5. Placing Calls and Messages43.2.6. Memory Management43.3. adb: Like DDMS, with More Typing
44.1. In the Beginning, There Was Java...44.2. ...And It Was OK44.3. Bucking the Trend44.4. Support, Structure44.5. Caveat Developer
45.1. Offline Applications45.1.1. What Does It Mean?45.1.2. How Do You Use It?45.1.2.1. About the Sample App45.1.2.2. "Installing" Checklist on Your Android Device45.1.2.3. Examining the HTML45.1.2.4. Examining the Manifest45.2. Web Storage45.2.1. What Does It Mean?45.2.2. How Do You Use It?45.2.3. Web SQL Database45.3. Going to Production45.3.1. Testing45.3.2. Signing and Distribution45.3.3. Updates45.4. Issues You May Encounter45.4.1. Android Device Versions45.4.2. Screen Sizes and Densities45.4.3. Limited Platform Integration45.4.4. Performance and Battery45.4.5. Look and Feel45.4.6. Distribution45.5. HTML5 and Alternative Android Browsers45.6. HTML5: The Baseline
46.1. What Is PhoneGap?46.1.1. What Do You Write In?46.1.2. What Features Do You Get?46.1.3. What Do Apps Look Like?46.1.4. How Does Distribution Work?46.1.5. What About Other Platforms?46.2. Using PhoneGap46.2.1. Installation46.2.2. Creating and Installing Your Project46.2.3. PhoneGap Build46.3. PhoneGap and the Checklist Sample46.3.1. Sticking to the Standards46.3.2. Adding PhoneGap APIs46.3.2.1. Set Up Device-Ready Event Handler46.3.2.2. Use What PhoneGap Gives You46.4. Issues You May Encounter46.4.1. Security46.4.2. Screen Sizes and Densities46.4.3. Look and Feel46.5. For More Information
47.1. Rhodes47.2. Flash, Flex, and AIR47.3. JRuby and Ruboto47.4. Mono for Android47.5. App Inventor47.6. Titanium Mobile47.7. Other JVM Compiled Languages
48.1. This App Contains Explicit Instructions48.1.1. Explicit Feature Requests48.1.2. Implied Feature Requests48.2. A Guaranteed Market48.3. Other Stuff That Varies48.4. Bugs, Bugs, Bugs48.5. Device Testing
49.1. Questions, Sometimes with Answers49.2. Heading to the Source49.3. Getting Your News Fix

Overview

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.