book

Beginning Android 3

Name: Beginning Android 3
Author: Mark Murphy
ISBN: 9781430232971

by Mark Murphy

July 2011

Beginner

612 pages

12h 12m

English

Apress

Read now

Unlock full access

Copyright
About the Author
About the Technical Reviewer
Acknowledgments
Preface
Welcome to the Book!PrerequisitesEditions of This BookSource Code and Its License
I. Core Concept
1. The Big Picture
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. How to Get Started
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. Your First Android Project
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. Examining Your First Project
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. A Bit About Eclipse
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. Enhancing Your First Project
6.1. Supporting Multiple Screen Sizes6.2. Specifying Versions
II. Activities
7. Rewriting Your First Project
7.1. The Activity7.2. Dissecting the Activity7.3. Building and Running the Activity
8. Using XML-Based Layouts
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. Employing Basic Widgets
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. Working with Containers
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. The Input Method Framework
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. Using Selection Widgets
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. Getting Fancy with Lists
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. Still More Widgets and Containers
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. Embedding the WebKit Browser
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. Applying Menus
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. Showing Pop-Up Messages
17.1. Raising Toasts17.2. Alert! Alert!17.3. Checking Them Out
18. Handling Activity Lifecycle Events
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. Handling Rotation
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. Dealing with Threads
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. Creating Intent Filters
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. Launching Activities and Subactivities
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. Working with Resources
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. Defining and Using Styles
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. Handling Multiple Screen Sizes
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?
III. Honeycomb and Tablets
26. Introducing the Honeycomb UI
26.1. Why Honeycomb?26.2. What the User Sees26.3. The Holographic Theme26.4. Dealing with the Rest of the Devices
27. Using the Action Bar
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. Fragments
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. Handling Platform Changes
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. Accessing Files
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
IV. Data Stores, Network Services, and APIs
31. Using Preferences
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. Managing and Accessing Local Databases
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. Leveraging Java Libraries
33.1. Ants and JARs33.2. The Outer Limits33.3. Following the Script33.4. Reviewing the Script
34. Communicating via the Internet
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
V. Services
35. Services: The Theory
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. Basic Service Patterns
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. Alerting Users via Notifications
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
VI. Other Android Capabilities
38. Requesting and Requiring Permissions
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. Accessing Location-Based Services
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. Mapping with MapView and MapActivity
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. Handling Telephone Calls
41.1. Report to the Manager41.2. You Make the Call!41.3. No, Really, You Make the Call!
42. Fonts
42.1. Love the One You're With42.2. Additional Fonts42.3. Here a Glyph, There a Glyph
43. More Development Tools
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
VII. Alternative Application Environments
44. The Role of Alternative Environments
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. HTML5
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. PhoneGap
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. Other Alternative Environments
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
VIII. The Ever-Evolving Android
48. Dealing with Devices
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. Where Do We Go from Here?
49.1. Questions, Sometimes with Answers49.2. Heading to the Source49.3. Getting Your News Fix

Content preview from Beginning Android 3

Chapter 11. The Input Method Framework

Android 1.5 introduced the input method framework (IMF), which is commonly referred to as soft keyboards. However, this term is not necessarily accurate, as IMF could be used for handwriting recognition or other means of accepting text input via the screen.

Keyboards, Hard and Soft

Some Android devices have a hardware keyboard that is visible some of the time (when it is slid out). A few Android devices have a hardware keyboard that is always visible (so-called "bar" or "slab" phones). Most Android devices, though, have no hardware keyboard at all. The IMF handles all of these scenarios.

In short, if there is no hardware keyboard, an input method editor (IME) will be available to the user when they tap an enabled ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781430232971Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Beginning Android 3

by Mark Murphy

Chapter 11. The Input Method Framework

Keyboards, Hard and Soft

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.