W. Frank Ableson . Robi Sen . Chris King . C. Enrique Ortiz
MANNING
SHELTER ISLAND
Manning Publications Co.
20 Baldwin Road
PO Box 261
Shelter Island, NY 11964
Email: orders@manning.com
SHELTER ISLAND
Manning Publications Co.
20 Baldwin Road
PO Box 261
Shelter Island, NY 11964
Email: orders@manning.com
 |
| Android in Action Third Edition |
acknowledgments
Writing a third edition of Android in Action feels somewhat like the old saying about
weddings: “Something old, something new…” The deadlines for the third edition did
not become any easier as at last count there are still only 24 hours in the day. And as
for something new—it seems as though Android’s pace of innovation is continuing to
match its adoption rate by mobile users around the globe. Like the two earlier editions,
Android in Action, Third Edition represents a collaboration between a number of
contributors. I had the privilege of working again with Robi Sen and Chris King, who
worked with me on the second edition. C. Enrique Ortiz joined us to contribute the
tablet content. Once again the talented team at Manning have labored to bring about this edition.
In particular, we’d like to acknowledge and thank everyone at Manning. First,
thanks to Troy Mott, our acquisition and development editor, who has been involved
in every aspect of now three editions of this project—congratulations, Troy, on your
hat-trick! Bob Herbstman did all the big and little things to bring the project together;
Mary Piergies skillfully piloted the team through the harrowing production process;
and Marjan Bace, our publisher, showed an attention to detail at once challenging,
beneficial, and appreciated.
Once the writing was finished, the next round of work began. Special thanks need
to go to Benjamin Berg, who performed the preproduction editing pass; Tiffany Taylor,
who did the second copyediting pass and helped us bring the final pieces of the
project together; and finally Dottie Marsico, who handled the actual layout of the
pages. It’s sometimes hard to envision the final product when looking at edits upon
edits in MS Word, but Dottie’s magic made the product you hold in your hands. Next,
we would like to thank Candace Gillhoolley for her efforts in getting the word out
about the book. Thanks to each of you for your special contribution to this project.
And special thanks to the reviewers who read our revised manuscript at different
times during its development: Steve Prior, Matthew Johnson, Julian Harty, David
Strong, Loïc Simon, Al Scherer, Gabor Paller, and Pieter Kuijpers; and to Jérôme
Bâton for his careful technical review of the final manuscript during production.
Last, we want to thank the thoughtful and encouraging MEAP subscribers who provided
feedback along the way; the book is better thanks to your contributions.
FRANK ABLESON
I would like to thank my coauthors: Robi Sen, a real pro who has been involved in this
project from the beginning; Chris King, who has proven to be rock-solid in terms of
both technical capability and reliability; and newcomer C. Enrique Ortiz (CEO), who
has injected energy and enthusiasm into the Third Edition. Of course, through each
iteration of this project, Troy Mott has led the way: managing the process, coaxing us
at times, and delivering every time. Bob Herbstman has contributed invaluably to the
finished product and is likely tired of cleaning up after my writing and amateurish
graphics after all of these years. Special thanks to Bob for re-creating many illustrations.
Thanks also to the production team at Manning Publications who have once
again delivered an excellent work. Thanks also to Candace Gillhoolley for continued
support with books and promotions to support speaking events and conferences—
always aiding my last-minute requests. Last and most important, I would like to thank
Nikki and company at the Ableson household for unconditional support. Praise be to
God, another version is complete!
CHRIS KING
I am deeply grateful to Troy Mott, Frank, Robi, and Enrique for being such a pleasure
to collaborate with as we drove toward the latest incarnation of this book. I also appreciate
all the work done by the reviewers and editors from Manning, and also the dedicated
readers of previous editions who contributed suggestions at the Author Online
forums. Special thanks go to Eric Tamo and Zac White for their support and relentless
good cheer. Finally, my love to my family: Charles, Karen, Patrick, Kathryn, and Andrew.
ROBI SEN
I would like to thank Troy Mott and the team—and everyone at Manning Publications—
for their hard work making this book something worth reading. I would like to
thank my coauthors, Frank and Chris, who were great to work with and very understanding
when I was the one holding things up. I would also like to thank C. Enrique
Ortiz for his contributions. Finally, I would like to dedicate my efforts on this book to
my brother Neel, who passed away while we were wrapping up the book.
C. ENRIQUE ORTIZ
To my parents, family, friends, and colleagues, who influence my work and make it exciting.
preface
The idea of a writing a book about Android development can be somewhat futile at
times, considering the pace at which Android continues to expand, morph, and
change. What started out as a book project a few years ago has now become a series of
updates to the original work with the page count nearly double the original project—
and that after making hard decisions about what to leave out of the book to make sure it gets published.
This update to Android in Action represents our latest effort to provide coverage
on important Android development topics, namely the expansion into the tablet
space with Android 3.x as well as advances in mobile graphics and media such as RenderScript.
Although there have been many off-brand and name-brand tablet offerings popping
up over time, the Android development team has taken the step of adding tabletspecific
capabilities to the SDK under the banner of 3.0. True to form, 3.0 was quickly
updated, so we generally refer to the tablet-specific features as 3.x; and before long I
am sure Android 4.x will be out with a super-set of features.
Like many things in life, the only constant is change, but by now we’re somewhat
accustomed to the rapid-fire environment of Android development. To that end, we
have ensured that all of the applications in the book work with Android 3.x. The newest
chapters covering tablet-specific content (20–22) require the 3.x SDK, whereas the
remaining chapters are compatible with the 2.x SDK versions. If you plan to write application
software for Android, you simply need to steel yourself for navigating the multiple
version game. It is at once a strength and a challenge of the Android ecosystem.
The third edition was written by Frank Ableson, Robi Sen, Chris King, and newcomer
C. Enrique Ortiz, aka CEO. To borrow a line from the air-travel industry, “We
know you have a choice when it comes to Android development books, so thank you
for learning and collaborating with us.”
FRANK ABLESON
about this book
Android in Action, Third Edition is a revision and update of, you guessed it, the Second
Edition, published in January 2011. This third edition adds new content related to
Android’s push into the tablet space as well as enhancements to various sub-systems
within the Android platform. Like its predecessors, this book covers important beginner
topics such as “What is Android?” and installing and using the development environment.
We then advance to practical working examples of core programming topics
any developer will be happy to have at the ready on the reference shelf. The remaining
chapters present detailed example applications covering advanced topics, including
a complete field-service application, localization, and material on Android web
applications, Bluetooth, sensors, AppWidgets, and integration adapters. We even
include two chapters on writing applications in C—one for the native side of Android
and one using the more generally accepted method of employing the Android Native
Development Kit. Brand-new content covering tablet programming is found in chapters
20 through 22. Chapters 20–22 specifically require Android SDK 3.0 and beyond,
whereas the balance of the book is compatible with 2.x versions of Android.
Although you can read the book from start to finish, you can also consider it a few
books in one. If you’re new to Android, focus first on chapter 1, appendix A, and then
chapter 2. With that foundation, you can work your way through chapters 3–12. Chapters
13 and on are more in-depth in nature and can be read independently of the others.
Chapters 20–22 focuses on important topics related to Android 3.0 and tablets.
Who should read this book?
We wrote this book for professional programmers and hobbyists alike. Many of the
concepts can be absorbed without specific Java language knowledge, although you’ll
obtain the most value if you have Java programming skills—Android application programming
requires them. If you have C, C++, or C# programming knowledge, you’ll
be able to follow the examples.
Prior Eclipse experience is helpful, but not required. A number of good resources
are available on Java and Eclipse to augment the content of this book.
Roadmap
This book is divided into four parts. Part 1 contains introductory material about the
platform and development environment. Part 2 takes a close look at the fundamental
skills required for building Android applications. Part 3 presents a larger-scope application
and a Native C Android application. Part 4 explores features added to the
Android platform, providing examples of using the capable Android platform to create
innovative mobile applications.
Part 1: The essentials
Part 1 introduces the Android platform, including its architecture and setting up the
development environment.
Chapter 1 delves into the background and positioning of the Android platform,
including comparisons to other popular platforms such as BlackBerry, iPhone, and
Windows Mobile. After an introduction to the platform, the balance of the first chapter
introduces the high-level architecture of Android applications and the operating system environment.
Chapter 2 takes you on a step-by-step development exercise, teaching you the ropes
of using the Android development environment, including the key tools and concepts
for building an application. If you’ve never used Eclipse or have never written an
Android application, this chapter will prepare you for the next part of the book.
Part 2: The programming environment
Part 2 includes an extensive survey of fundamental programming topics in the Android environment.
Chapter 3 covers the fundamental Android UI components, including View and
Layout. We also review the Activity in more detail. These are the basic building
blocks of screens and applications on the Android platform. Along the way, we also
touch on other basic concepts such as accessing external resources, responding to
events, and the lifecycle of an Android application.
Chapter 4 expands on the concepts you learned in chapter 3. We delve into the
Android Intent to demonstrate interaction between screens, activities, and entire
applications. We also introduce and use the Service framework, which allows for
ongoing background processes.
Chapter 5 incorporates methods and strategies for storing and retrieving data
locally. The chapter examines use of the filesystem, databases, the SD card, and
Android-specific storage entities such as the SharedPreferences and ContentProvider
classes. This chapter begins combining fundamental concepts with more real-world
details, such as handling application state, using a database for persistent storage, and
working with SQLite.
Chapter 6 deals with storing and retrieving data over the network. Here we include
a networking primer before delving into using raw networking concepts such as sockets
on Android. From there, we progress to using HTTP, and even explore web services
(such as REST and SOAP).
Chapter 7 covers telephony on the Android platform. We touch on basics such as
originating and receiving phone calls, as well as more involved topics such as identifying
cell towers and sending or receiving SMS messages.
Chapter 8 looks at how to work with notifications and alarms. In this chapter, we
look at how to notify users of various events such as receiving a SMS message, as well as
how to manage and set alarms.
Chapter 9 deals with the basics of Android’s Graphics API and more advanced concepts
such as working with the OpenGL ES library for creating sophisticated 2D and
3D graphics. We also touch on animation as well as Android’s new graphics systems RenderScript.
Chapter 10 looks at Android’s support for multimedia; we cover both playing
multimedia as well as using the camera and microphone to record your own multimedia files.
Chapter 11 introduces location-based services as we look at an example that combines
many of the concepts from the earlier parts of the book in a mapping application.
You’ll learn about using the mapping APIs on Android, including different
location providers and properties that are available, how to build and manipulate maprelated
screens, and how to work with location-related concepts within the emulator.
Part 3: Bringing it all together
Part 3 contains two chapters, both of which build on knowledge you gained earlier in
the text, with a focus on bringing a larger application to fruition.
Chapter 12 demonstrates an end-to-end field service application. The application
includes server communications, persistent storage, multiple Activity navigation
menus, and signature capture.
Chapter 13 explores the world of native C language applications. The Android SDK
is limited to the Java language, although native applications can be written for
Android. This chapter walks you through examples of building C language applications
for Android, including the use of built-in libraries and TCP socket communications
as a Java application connects to your C application. This chapter is useful for
developers targeting solutions beyond carrier-subsidized, locked-down cell phones.
Part 4: The maturing platform
Part 4 contains nine new chapters, each of which represents a more advanced development topic.
Chapter 14 demonstrates the use of both Bluetooth communication and processing
sensor data. The sample application accompanying the chapter, SenseBot, permits
the user to drive a LEGO Mindstorms robot with their Android phone.
Chapter 15 explores the Android contact database and demonstrates integrating
with an external data source. In particular, this application brings Android into the
social-networking scene by integrating with the popular LinkedIn professional networking service.
Chapter 16 explores the world of web development. Android’s browser is based on
the open source WebKit engine and brings desktop-like capability to this mobile
browser. This chapter equips you to bring attractive and capable web applications to Android.
Chapter 17 brings the home screen of your Android application to life by showing
you how to build an application that presents its user interface as an AppWidget. In
addition to AppWidgets, this chapter demonstrates BroadcastReceiver, Service, and Alarms.
Chapter 18 takes a real-world look at localizing an existing application.
Chapter 12’s Field Service application is modified to support multiple languages.
Chapter 18’s version of the Field Service application contains support for both English and Spanish.
Chapter 19 reaches into Android’s open source foundation by using a popular
edge-detection image-processing algorithm. The Sobel Edge Detection algorithm is
written in C and compiled into a native library. The sample application snaps a picture
with the Android camera and then uses this C algorithm to find the edges in the photo.
Chapter 20 covers Android Fragments, a new application component that was
introduced with Android 3.0. Fragments provide more granular application control
than working only with Activitys alone.
Chapter 21 explores the action bar. Also introduced with Android 3.0, the action
bar provides a consistent look-and-feel for the application title, icon, actions, and menu options.
Chapter 22 introduces the new drag-and-drop API, also introduced with
Android 3.0. The drag-and-drop API allows for touch-based, interactive operations: for
example, to move or copy data across views by visually selecting data from one view
and dropping it onto another view on the screen. Another example is to trigger application
actions: for example, image sharing by dragging an image from an image gallery view onto a sharing view.
Appendixes
The appendixes contain additional information that didn’t fit with the flow of the main
text. Appendix A is a step-by-step guide to installing the development environment.
This appendix, along with chapter 2, provides all the information you need to build an
Android application. Appendix B demonstrates how to prepare and submit an application
for the Android Market—an important topic for anyone looking to sell an application
commercially.
about the cover illustration
The illustration on the cover of Android in Action, Third Edition is taken from a French
book of dress customs, Encyclopédie des Voyages by J. G. St. Saveur, published in 1796.
Travel for pleasure was a relatively new phenomenon at the time and illustrated
guides such as this one were popular, introducing both the tourist as well as the armchair
traveler to the inhabitants of other regions of the world, as well as to the
regional costumes and uniforms of France.
The diversity of the drawings in the Encyclopédie des Voyages speaks vividly of the
uniqueness and individuality of the world’s countries and regions just 200 years ago.
This was a time when the dress codes of two regions separated by a few dozen miles
identified people uniquely as belonging to one or the other, and when members of a
social class or a trade or a tribe could be easily distinguished by what they were wearing.
This was also a time when people were fascinated by foreign lands and faraway
places, even though they could not travel to these exotic destinations themselves.
Dress codes have changed since then and the diversity by region and tribe, so rich
at the time, has faded away. It is now often hard to tell the inhabitant of one continent
from another. Perhaps, trying to view it optimistically, we have traded a world of cultural
and visual diversity for a more varied personal life. Or a more varied and interesting
intellectual and technical life.
We at Manning celebrate the inventiveness, the initiative, and the fun of the computer
business with book covers based on native and tribal costumes from two centuries
ago brought back to life by the pictures from this travel guide.
Screenshot
Purchase Now !
Just with Paypal
Just with Paypal
Product details
Price
|
|
|---|---|
File Size
| 15,310 KB |
Pages
|
662 p |
File Type
|
PDF format |
ISBN
| 9781617290503 |
Copyright
| 2012 by Manning Publications Co |
Brief Contents
PART 1 WHAT IS ANDROID? THE BIG PICTURE
1 ■ Introducing Android 3
2 ■ Android’s development environment 33
PART 2 EXERCISING THE ANDROID SDK
3 ■ User interfaces 65
4 ■ Intents and Services 102
5 ■ Storing and retrieving data 130
6 ■ Networking and web services 160
7 ■ Telephony 188
8 ■ Notifications and alarms 206
9 ■ Graphics and animation 226
10 ■ Multimedia 260
11 ■ Location, location, location 284
PART 3 ANDROID APPLICATIONS
12 ■ Putting Android to work in a field service application 311
13 ■ Building Android applications in C 356
PART 4 THE MATURING PLATFORM
14 ■ Bluetooth and sensors 385
15 ■ Integration 405
16 ■ Android web development 439
17 ■ AppWidgets 472
18 ■ Localization 509
19 ■ Android Native Development Kit 524
20 ■ Activity fragments 545
21 ■ Android 3.0 action bar 560
22 ■ Drag-and-drop 579
Contents
preface xix
acknowledgments xxi
about this book xxiii
about the cover illustration xxviii
PART 1 WHAT IS ANDROID? THE BIG PICTURE...................1
1 Introducing Android
1.1 The Android platform 4
1.2 Understanding the Android market 5
Mobile operators 5 ■ Android vs. the feature phones 6
Android vs. the smartphones 7 ■ Android vs. itself 8
Licensing Android 9
1.3 The layers of Android 10
Building on the Linux kernel 11 ■ Running in the
Dalvik VM 12
1.4 The Intent of Android development 13
Empowering intuitive UIs 13 ■ Intents and how they work 14
1.5 Four kinds of Android components 17
Activity 17 ■ Service 18 ■ BroadcastReceiver 19
ContentProvider 22
1.6 Understanding the AndroidManifest.xml file 24
1.7 Mapping applications to processes 26
1.8 Creating an Android application 26
1.9 Android 3.0 for tablets and smartphones 30
Why develop for Android tablets? 30 ■ What’s new in the
Android 3.0 Honeycomb platform? 31
1.10 Summary 32
2 Android’s development environment 33
2.1 Introducing the Android SDK 34
Core Android packages 35 ■ Optional packages 36
2.2 Exploring the development environment 36
The Java perspective 37 ■ The DDMS perspective 39
Command-line tools 42
2.3 Building an Android application in Eclipse 45
The Android Project Wizard 45 ■ Android sample
application code 46 ■ Packaging the application 52
2.4 Using the Android emulator 53
Setting up the emulated environment 54 ■ Testing your
application in the emulator 58
2.5 Debugging your application 59
2.6 Summary 61
PART 2 EXERCISING THE ANDROID SDK .........................63
3 User interfaces 65
3.1 Creating the Activity 66
Creating an Activity class 68 ■ XML vs. programmatic
layouts 69 ■ Exploring the Activity lifecycle 72 ■ The server
connection 73
3.2 Working with views 75
Exploring common views 76 ■ Using a ListView 78
Multitasking with Handler and Message 82 ■ Creating custom
views 83 ■ Understanding layout 86 ■ Handling focus 88
Grasping events 89
3.3 Using resources 90
Supported resource types 90 ■ Referencing resources in
Java 91 ■ Defining views and layouts through XML
resources 93 ■ Externalizing values 95 ■ Providing
animations 98
3.4 Exploring the AndroidManifest file 99
3.5 Summary 101
4 Intents and Services 102
4.1 Serving up RestaurantFinder with Intent 103
Defining Intents 103 ■ Implicit and explicit invocation 104
Adding external links to RestaurantFinder 105 ■ Finding your
way with Intent 107 ■ Taking advantage of Android-provided
activities 109
4.2 Checking the weather with a custom URI 110
Offering a custom URI 110 ■ Inspecting a custom URI 112
4.3 Checking the weather with broadcast receivers 114
Broadcasting Intent 114 ■ Creating a receiver 115
4.4 Building a background weather service 116
4.5 Communicating with the WeatherAlertService from other apps 120
Android Interface Definition Language 120 ■ Binder and
Parcelable 122 ■ Exposing a remote interface 123
Binding to a Service 124 ■ Starting vs. binding 127
Service lifecycle 128
4.6 Summary 129
5 Storing and retrieving data 130
5.1 Using preferences 131
Working with SharedPreferences 131 ■ Preference access
permissions 134
5.2 Using the filesystem 137
Creating files 137 ■ Accessing files 138 ■ Files as raw
resources 139 ■ XML file resources 140 ■ External storage
via an SD card 142
5.3 Persisting data to a database 145
Building and accessing a database 146 ■ Using the sqlite3
tool 150
5.4 Working with ContentProvider classes 151
Using an existing ContentProvider 151 ■ Creating a
ContentProvider 152
5.5 Summary 159
6 Networking and web services 160
6.1 An overview of networking 162
Networking basics 162 ■ Clients and servers 164
6.2 Checking the network status 165
6.3 Communicating with a server socket 166
6.4 Working with HTTP 169
Simple HTTP and java.net 170 ■ Robust HTTP with
HttpClient 171 ■ Creating an HTTP and HTTPS helper 173
6.5 Web services 179
POX: putting it together with HTTP and XML 180
REST 182 ■ To SOAP or not to SOAP, that is the question 185
6.6 Summary 186
7 Telephony 188
7.1 Exploring telephony background and terms 189
Understanding GSM 190 ■ Understanding CDMA 190
7.2 Phone or not? 191
7.3 Accessing telephony information 192
Retrieving telephony properties 192 ■ Obtaining phone state
information 195
7.4 Interacting with the phone 196
Using Intents to make calls 196 ■ Using phone number–related
utilities 198 ■ Intercepting outbound calls 200
7.5 Working with messaging: SMS 200
Sending SMS messages 201 ■ Receiving SMS messages 204
7.6 Summary 205
8 Notifications and alarms 206
8.1 Introducing Toast 207
8.2 Placing your Toast message 209
8.3 Making a custom Toast view 210
8.4 Introducing notifications 212
The Notification class 212 ■ Notifying a user with a simple button press 214
8.5 Making a custom notification view 216
8.6 Introducing alarms 219
Creating a simple alarm example 220 ■ Using notifications
with alarms 222
8.7 Summary 225
9 Graphics and animation 226
9.1 Drawing graphics in Android 227
Drawing with XML 228 ■ Exploring XML drawable shapes 230
9.2 Creating animations with Android’s Graphics API 231
Android’s frame-by-frame animation 232 ■ Programmatically
creating an animation 234
9.3 Introducing OpenGL for Embedded Systems 238
Creating an OpenGL context 239 ■ Drawing a rectangle with
OpenGL ES 243 ■ Three-dimensional shapes and surfaces with
OpenGL ES 245
9.4 Introducing RenderScript for Android 250
RenderScript advantages and disadvantages 251 ■ Building a
RenderScript application 252
9.5 Summary 258
10 Multimedia 260
10.1 Introduction to multimedia and Stagefright 261
Stagefright overview 261
10.2 Playing audio 263
10.3 Playing video 264
10.4 Capturing media 266
Understanding the camera 267 ■ Capturing audio 272
Recording video 276
10.5 Summary 282
11 Location, location, location 284
11.1 Simulating your location within the emulator 286
Sending in your coordinates with the DDMS tool 286 ■ The GPS
Exchange Format 288 ■ The Google Earth Keyhole Markup
Language 289
11.2 Using LocationManager and LocationProvider 292
Accessing location data with LocationManager 292
Using a LocationProvider 294 ■ Receiving location
updates with LocationListener 296
11.3 Working with maps 298
Extending MapActivity 299 ■ Using a MapView 299
Placing data on a map with an Overlay 302
11.4 Converting places and addresses with Geocoder 305
11.5 Summary 307
PART 3 ANDROID APPLICATIONS...................................309
12 Putting Android to work in a field service application 311
12.1 Designing a real-world Android application 312
Core requirements of the application 313 ■ Managing the
data 314 ■ Application architecture and integration 315
12.2 Mapping out the application flow 316
Mapping out the field service application 316 ■ List of source
files 318 ■ Field service application’s AndroidManifest.xml 320
12.3 Application source code 320
Splash Activity 320 ■ Preferences used by the FieldService
Activity 322 ■ Implementing the FieldService Activity 324
Settings 325 ■ Managing job data 327
12.4 Source code for managing jobs 334
RefreshJobs 335 ■ Managing jobs: the ManageJobs Activity 338
Working with a job with the ShowJob Activity 341 ■ Capturing a
signature with the CloseJob Activity 345
12.5 Server code 351
Dispatcher user interface 352 ■ Database 352 ■ PHP
dispatcher code 353 ■ PHP mobile integration code 354
12.6 Summary 355
13 Building Android applications in C 356
13.1 Building Android apps without the SDK 357
The C compiler and linker tools 357 ■ Building a Hello World
application 358 ■ Installing and running the application 360
C application build script 362
13.2 Solving the problem with dynamic linking 362
Android system libraries 363 ■ Building a dynamically linked
application 364 ■ exit() vs. return() 367 ■ Startup code 368
13.3 What time is it? The DayTime Server 370
DayTime Server application 370 ■ daytime.c 371 ■ The SQLite
database 373 ■ Building and running the DayTime Server 376
13.4 Daytime Client 378
Activity 378 ■ Socket client 379 ■ Testing the Daytime Client 380
13.5 Summary 380
PART 4 THE MATURING PLATFORM .............................. 383
14 Bluetooth and sensors 385
14.1 Exploring Android’s Bluetooth capabilities 386
Replacing cables 387 ■ Primary and secondary roles and
sockets 387 ■ Trusting a device 388 ■ Connecting to a
remote device 390 ■ Capturing Bluetooth events 392
Bluetooth permissions 393
14.2 Interacting with the SensorManager 393
Types of sensors 394 ■ Reading sensor values 395
Enabling and disabling sensors 396
14.3 Building the SenseBot application 397
User interface 398 ■ Interpreting sensor values 400
Driving the robot 401 ■ Communication with the robot 402
14.4 Summary 403
15 Integration 405
15.1 Understanding the Android contact model 406
Choosing open-ended records 406 ■ Dealing with multiple
accounts 408 ■ Unifying a local view from diverse remote
stores 410 ■ Sharing the playground 411
15.2 Getting started with LinkedIn 411
15.3 Managing contacts 413
Leveraging the built-in Contacts app 413 ■ Requesting operations
from your app 416 ■ Directly reading and modifying the contacts
database 417 ■ Adding contacts 418
15.4 Keeping it together 421
The dream of sync 421 ■ Defining accounts 422 ■ Telling
secrets: The AccountManager service 423
15.5 Creating a LinkedIn account 424
Not friendly to mobile 424 ■ Authenticating to LinkedIn 425
15.6 Synchronizing to the backend with SyncAdapter 432
The synchronizing lifecycle 432 ■ Synchronizing LinkedIn data 432
15.7 Wrapping up: LinkedIn in action 435
Finalizing the LinkedIn project 435 ■ Troubleshooting tips 436
Moving on 437
15.8 Summary 437
16 Android web development 439
16.1 What’s Android web development? 440
Introducing WebKit 440 ■ Examining the architectural
options 441
16.2 Optimizing web applications for Android 442
Designing with mobile in mind 442 ■ Adding the viewport
tag 444 ■ Selectively loading content 446 ■ Interrogating the
user agent 446 ■ The media query 447 ■ Considering a madefor-
mobile application 448
16.3 Storing data directly in the browser 449
Setting things up 450 ■ Examining the code 451 ■ The user
interface 451 ■ Opening the database 453 ■ Unpacking the
transaction function 454 ■ Inserting and deleting rows 456
Testing the application with WebKit tools 457
16.4 Building a hybrid application 458
Examining the browser control 458 ■ Wiring up the control 459
Implementing the JavaScript handler 461 ■ Accessing the code
from JavaScript 463 ■ Digging into the JavaScript 463
Security matters 465 ■ Implementing a WebViewClient 466
Augmenting the browser 466 ■ Detecting navigation events 467
Implementing the WebChromeClient 470
16.5 Summary 471
17 AppWidgets 472
17.1 Introducing the AppWidget 473
What’s an AppWidget? 473 ■ AppWidget deployment
strategies 475
17.2 Introducing SiteMonitor 476
Benefits of SiteMonitor 476 ■ The user experience 477
17.3 SiteMonitor application architecture 480
Bird’s-eye view of the application 480 ■ File by file 482
17.4 AppWidget data handling 483
17.5 Implementing the AppWidgetProvider 487
AppWidgetProvider method inventory 487 ■ Implementing
SiteMonitorWidgetImpl 488 ■ Handling zombie widgets 490
17.6 Displaying an AppWidget with RemoteViews 491
Working with RemoteViews 491 ■ UpdateOneWidget
explained 492
17.7 Configuring an instance of the AppWidget 494
AppWidget metadata 495 ■ Working with Intent data 496
Confirming widget creation 497
17.8 Updating the AppWidget 498
Comparing services to alarms 499 ■ Triggering the update 500
Updating the widgets, finally! 502
17.9 Tying it all together with AndroidManifest.xml 506
17.10 Summary 507
18 Localization 509
18.1 The need for localization 510
18.2 Exploring locales 511
18.3 Strategies for localizing an application 512
Identifying target locales and data 512 ■ Identifying and
managing strings 513 ■ Drawables and layouts 515
Dates, times, numbers, and currencies 516 ■ Working with
the translation team 517
18.4 Leveraging Android resource capabilities 518
More than locale 518 ■ Assigning strings in resources 518
18.5 Localizing in Java code 520
18.6 Formatting localized strings 521
18.7 Obstacles to localization 522
18.8 Summary 523
19 Android Native Development Kit 524
19.1 Introducing the NDK 525
Uses for the NDK 525 ■ Looking at the NDK 526
19.2 Building an application with the NDK 527
Demonstrating the completed application 528 ■ Examining the
project structure 529
19.3 Building the JNI library 530
Understanding JNI 530 ■ Implementing the library 531
Compiling the JNI library 536
19.4 Building the user interface 537
User interface layout 537 ■ Taking a photo 539 ■ Finding the
edges 541
19.5 Integrating the NDK into Eclipse 542
19.6 Summary 544
20 Activity fragments 545
20.1 Fragment lifecyle 546
20.2 Creating fragments and fragment layouts 548
Create the fragment subclass 548 ■ Defining a fragment
layout 551 ■ Include the fragment within the activity 552
20.3 Background fragments 553
20.4 The fragment manager 555
20.5 Fragment transactions 555
20.6 Fragment back stack 556
20.7 The Android Compatibility Package 557
20.8 Summary 558
21 Android 3.0 action bar 560
21.1 Introducing the action bar 561
21.2 Overview of the ActionBar classes 562
21.3 Action bar display options 563
Application name and icon 564 ■ Navigation modes 565
21.4 Action items 570
The application icon as an action item 573 ■ Action views 574
21.5 Removing, showing, and hiding the action bar 575
21.6 Action bar styling 575
21.7 Summary 578
22 Drag-and-drop 579
22.1 The drag-and-drop classes 580
22.2 Drag-and-drop operations 581
22.3 The shadow builder 583
22.4 Drag events 585
22.5 Starting drag operations 586
22.6 Listening for drag-and-drop events 587
22.7 Responding to drag-start operations 588
22.8 Handling drop operations 589
22.9 Summary 590
appendix A Installing the Android SDK 591
appendix B Publishing applications 601
index 613
●▬▬▬▬▬❂❂❂▬▬▬▬▬●
●▬▬❂❂▬▬●
●▬❂▬●
●❂●
═════● ●═════
