Enterprise Android.pdf

DownLoad Book

Published: 2018-03-17 Author:Bieber 24 Browses

Tags: android


书名: Enterprise Android

作者: Zigurd Mednieks, G. Blake Meike, Laird Dornin, Zane Pan

副书名: Programming Android Database Applications for the Enterprise

出版日期: 2014

页数: 408

ISBN: 978-1-118-18349-6

Extracting password :44bf5e914ee208d2

ffirs.indd viiiffirs.indd viii 26-09-2013 19:13:3026-09-2013 19:13:30
INTRODUCTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
CHAPTER 1 Developing for Android Tablets and Smartphones . . . . . . . . . . . . . . . . . . . 1
CHAPTER 2 The Relational Model and SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
CHAPTER 3 Android Database Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
CHAPTER 4 Content Providers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
CHAPTER 5 REST, Content Providers, Concurrency,
Networking, and Sync Adapters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
CHAPTER 6 Service Development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .167
CHAPTER 7 Mobile and the Cloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
CHAPTER 8 Complex Device-Based Data: Android Contacts . . . . . . . . . . . . . . . . . . 245
CHAPTER 9 Generic Data Synchronization:
Project Migrate and the WebData API . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
CHAPTER 10 WebData Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
CHAPTER 11 Building Human Interfaces for Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
CHAPTER 12 Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
ffirs.indd iffirs.indd i 26-09-2013 19:13:2926-09-2013 19:13:29
ffirs.indd iiffirs.indd ii 26-09-2013 19:13:2926-09-2013 19:13:29
Enterprise Android
ffirs.indd iiiffirs.indd iii 26-09-2013 19:13:2926-09-2013 19:13:29
ffirs.indd ivffirs.indd iv 26-09-2013 19:13:2926-09-2013 19:13:29
Enterprise Android
Zigurd Mednieks
G. Blake Meike
Laird Dornin
Zane Pan
ffirs.indd vffirs.indd v 26-09-2013 19:13:2926-09-2013 19:13:29
Enterprise Android™: Programming Android Database Applications for the Enterprise
Published by
John Wiley & Sons, Inc.
10475 Crosspoint Boulevard
Indianapolis, IN 46256
Copyright © 2014 by John Wiley & Sons, Inc., Indianapolis, Indiana
Published simultaneously in Canada
ISBN: 978-1-118-18349-6
ISBN: 978-1-118-22747-3 (ebk)
ISBN: 978-1-118-24046-5 (ebk)
Manufactured in the United States of America
10 9 8 7 6 5 4 3 2 1
No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means,
electronic, mechanical, photocopying, recording, scanning or otherwise, except as permitted under Sections 107 or 108
of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization
through payment of the appropriate per-copy fee to the Copyright Clearance Center, 222 Rosewood Drive, Danvers,
MA 01923, (978) 750-8400, fax (978) 646-8600. Requests to the Publisher for permission should be addressed to the
Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) 748-6011,
fax (201) 748-6008, or online at
Limit of Liability/Disclaimer of Warranty: The publisher and the author make no representations or warranties with
respect to the accuracy or completeness of the contents of this work and speci cally disclaim all warranties, including
without limitation warranties of  tness for a particular purpose. No warranty may be created or extended by sales or
promotional materials. The advice and strategies contained herein may not be suitable for every situation. This work is
sold with the understanding that the publisher is not engaged in rendering legal, accounting, or other professional
services. If professional assistance is required, the services of a competent professional person should be sought. Neither
the publisher nor the author shall be liable for damages arising herefrom. The fact that an organization or Web site is
referred to in this work as a citation and/or a potential source of further information does not mean that the author or the
publisher endorses the information the organization or Web site may provide or recommendations it may make. Further,
readers should be aware that Internet Web sites listed in this work may have changed or disappeared between when this
work was written and when it is read.
For general information on our other products and services please contact our Customer Care Department within the
United States at (877) 762-2974, outside the United States at (317) 572-3993 or fax (317) 572-4002.
Wiley publishes in a variety of print and electronic formats and by print-on-demand. Some material included with
standard print versions of this book may not be included in e-books or in print-on-demand. If this book refers to media
such as a CD or DVD that is not included in the version you purchased, you may download this material at For more information about Wiley products, visit
Library of Congress Control Number: 2013936843
Trademarks: Wiley, , Wrox, the Wrox logo, Wrox Programmer to Programmer, and related trade dress are trademarks or
registered trademarks of John Wiley & Sons, Inc. and/or its af liates, in the United States and other countries, and may
not be used without written permission. Android is a trademark of Google, Inc. All other trademarks are the property of
their respective owners. John Wiley & Sons, Inc., is not associated with any product or vendor mentioned in this book.
ffirs.indd viffirs.indd vi 26-09-2013 19:13:3026-09-2013 19:13:30
To Maija and Charles
Z M
To Jerry Meike, my inspiration for writing a book...
and a lot more
G. B M
To Norah and Claire, my girls
L D
To Zhengfang
Z P
ffirs.indd viiffirs.indd vii 26-09-2013 19:13:3026-09-2013 19:13:30
ffirs.indd viiiffirs.indd viii 26-09-2013 19:13:3026-09-2013 19:13:30
ZIGURD MEDNIEKS is a consultant to leading OEMs, enterprises, investors, and entrepreneurial
ventures creating Android-based systems and software. Previously, he was Chief Architect at D2
Technologies, a voice-over-IP (VoIP) technology provider. There he led engineering and product-
de nition work for products that blend communication and social media in purpose-built embedded
systems and on the Android platform.
Zigurd is a 25-year veteran of user interface, telephony, and social media product creation in
the computing and telecommunications industries. He has authored and co-authored books
about Android software development, and written book chapters on telephony and inter-process
communication. His  rst book, C Programming Techniques for the Macintosh, co-authored with
Terry Mednieks, was published in 1986. Information about Zigurd can be found at
G. BLAKE MEIKE is a passionate engineer and code poet with more than 20 years of experience. He
has spent much of his time working with Java, building systems as large as Amazon’s massively
scalable Auto Scaling service and as small as a pre-Android OSS/Linux- and Java-based platform
for cell phones. He is co-author of the bestselling Programming Android and has taught nearly a
thousand people the art of writing Android apps that aren’t toys.
LAIRD DORNIN graduated from Williams College in 1997 with a Bachelor of Arts degree in
Computer Science. Laird began his career at Sun Microsystems working on the Java JDK (RMI) and
the forward-looking Jini Technology out of Sun Labs. From there he moved to SavaJe Technologies
and helped to build a full-featured Java SE mobile operating system that shipped in 2006 and pro-
vided the platform for “Device of the Show” at JavaOne. Again at Sun Microsystems, Laird contin-
ued working on SavaJe OS to integrate the WebKit browser library to provide a full-featured mobile
browser. Laird is an author of two books on Android programmingand now works as an architect
for a major wireless carrier.
ZANE PAN began building large, scalabledistributed systems at Sun Microsystems Labs working
on Jini Technology in the late ‘90s. He has been actively designing and architecting solutions for
distributed computing performance and scalability problems since then. Zane has held architect
level roles at many large companies including Lotus Development Corporation, Digital Equipment
Corporation, Intuit, and EMC. Most recently, Zane architected and built a large-scale mobile ser-
vice backend system using Big Data and NoSQL at Nokia.
ffirs.indd ixffirs.indd ix 26-09-2013 19:13:3026-09-2013 19:13:30
JIM FITZGERALD has worked in many facets of the technology industry. His humble beginnings
in Silicon Valley as a software engineer for Hewlett-Packard eventually led him to positions in
marketing and sales before graduate school brought him back to software development and
project management. He has programmed in many different languages and operating systems,
from old mainframes to Windows desktops, and currently spends his time in Android and
Windows mobile environments. While he considers himself more of a frontend guy, he will
admit to dabbling with PHP and writing a lot of PL/SQL in the past when pressed.
When not investigating how technical things work, Jim spends his time as a bibliophile, avid artist
and photographer, collecting far more books, paint brushes, and lenses than he can hope to use.
Jim has a undergraduate BS degree from California Polytechnic, and a MS degree from Yale
MAIJA MEDNIEKS is a senior at the Carnegie Mellon University School of Computer Science and a
former buggy driver. Among her interests are knitting, Norse epics, science  ction, interactive user
experience design, creating and solving puzzles for puzzle hunts, and functional programming.
ffirs.indd xffirs.indd x 26-09-2013 19:13:3026-09-2013 19:13:30
Robert Elliott
Kevin Kent
Maija Mednieks
Christine Mugnolo
Kezia Endsley
Mary Beth Wakefi eld
Rosemarie Graham
David Mayhew
Ashley Zurcher
Amy Knies
Tim Tate
Richard Swadley
Neil Edde
Jim Minatel
Katie Crocker
Nancy Carrasco
Jim Fitzgerald
John Sleeva
Ryan Sneed
© Neliubov
ffirs.indd xiffirs.indd xi 26-09-2013 19:13:3026-09-2013 19:13:30
I WANT TO THANK the editors at Wiley who have the vision to publish books about Android in the
enterprise; our agent, Carole Jelen, for bringing this project to us; and my co-authors who brought the
concept of a book about data-oriented apps to life. I also thank Maija Mednieks and Jim Fitzgerald,
the technical editor and technical proofreader, for their exacting attention to making sure our
examples work.
—Z M
I WOULD LIKE TO THANK my co-authors, Zigurd, Laird, and Zane, for making this book way bigger
than the sum of its parts. Bob Elliott and Kevin Kent were incredibly patient with us; and the rest of
the editors, Maija Mednieks, Christine Mugnolo, Kezia Endsley, and Jim Fitzgerald, kept us honest
and intelligible. Marakana Inc., my employer, gave me time to work on it. A special shout out to
L. Carl Pedersen for taking the time to explain SQL. As always, a project like this would be
impossible without the support of my wife, Catherine. You and me, babe, ‘til the wheels fall off.
G. B M
I NEED TO THANK my sweetie, Norah, for being so patient with all the long weekends and late nights
working on this ambitious project. You’ve been amazing for this, and for carrying another far more
important project—our new son.
Thanks to my parentswe’ve missed trips to NH!
I’d like to thank Kevin and Robert for all their excellent support on this project. I’m excited that we
managed to cover so many popular topics to create a comprehensive picture of end-to-end enterprise
Android development. Thanks to Jim and Maija, our reviewers; this book contained a lot of material
to cover. Thanks to my brother, Chris, and to Nathan Babb for reviewing parts of the manuscript.
Finally, thanks to my co-authors for collaborating to bring this project to completion.
—L D
I’D LIKE TO THANK Kevin and Robert for their support on this project.
—Z P
ffirs.indd xiiffirs.indd xii 26-09-2013 19:13:3026-09-2013 19:13:30
Android Is a Java Operating System 2
Your Tools and Your First Android App 2
Prerequisites and Getting Ready 2
Toolchain Test Drive 4
One Code-Base for All Types of Devices 4
Getting Started with the Code Framework Example 5
Automatically Adapting to Screen Size 10
Components, Views, and Lifecycle 11
Destroying and Re-Creating Components 11
The MainActivity Class 12
Activity: The Basic Unit of User Interaction 12
Fragment: A Tool for Organizing Code and UI 17
The PickFragment Class 18
The ItemFragment Class 22
The ItemDetailFragment Class 25
Tying Together Activities, Fragments,
and the Action Bar 25
The TabbedActivity Class 25
A Main.xml File for Large Tablets 28
A Main.xml and a Subsidiary Activity for Smaller Screens 29
The TabActivity Class 30
The Android Task and Process Model 33
Starting Dalvik Instances 34
Death, but No Trans guration 34
Tasks Span Applications and Processes 35
Multiprocessing, Security, and Lifecycle 35
The Process and User ID as Security Boundary 36
Declaring Application Properties 36
Summary 37
ftoc.indd xiiiftoc.indd xiii 26-09-2013 19:12:5926-09-2013 19:12:59
Databases and the Relational Model 40
The History of the RDBMS 41
The Relational Model 41
Other DBMS Features 43
The SQL Language 45
Introduction to SQLite 48
SQLite from the Command Line 49
An Example SQLite Database 53
Summary 58
SQL in Java: The SQLiteDatabase Class 60
Basic SQL Embedding 60
Syntactic SQL 61
Creating a Database: The SQLiteOpenHelper Class 67
Managing a Database 71
Cursors, Loaders, and Adapters 73
Cursors 74
Adapters and View Binders 76
Loaders 79
Summary 81
Using a Content Provider 84
URIs as Names for Virtual Datasets 84
Content Resolvers: The Link between Clients and Providers 85
Content Observers: Completing the Loop 87
IPC: System-Wide Accessibility 89
The Contract: URIs and Types 90
Authority 91
Virtual Table URIs 93
Return Value MIME Types 94
Permissions 94
Publishing the Contract 95
Implementing the Content Provider 95
Creating the Content Provider 96
Return Types and the URI Matcher 97
Writing the Database 98
Database Queries 101
Content Observers (Again) 105
ftoc.indd xivftoc.indd xiv 26-09-2013 19:12:5926-09-2013 19:12:59
Permissions and Registration 106
Content Providers and Files 109
Summary 114
Basic REST 116
Why REST? 117
REST over HTTP 118
An Example REST API 120
Contact Representation 120
Contact Methods and URIs 122
Contact Transactions 122
Android Networking 125
The Apache Libraries 125
The Libraries 126
Permissions 128
Considering Concurrency and Lifecycles 128
The Android Concurrency Architecture 128
A Naive Request 129
An Architecture for Robust Networking 131
Approach 1: Service-Centric 131
Approach 2: ContentProvider-Centric 133
Approach 3: SyncAdapter-Centric 135
REST within Android 135
The restfulCachingProviderContacts Project: An Example Client 136
Adding a Contact 138
Using Sync Adapters 143
Android Account Management 144
Creating a Sync Adapter 155
Summary 165
A Choice for Service Development 168
The Lifecycle of a Request 168
Three-Tier Service Architecture 169
Service Development Background 169
Building a RESTful Service for Contacts 172
A Conservative Software Stack 172
Writing the Examples: Spring Contacts Service
and Its Synchronization Variant 175
Code Example: Spring Sync Contacts Service 195
Summary 202
ftoc.indd xvftoc.indd xv 26-09-2013 19:12:5926-09-2013 19:12:59
Cloud Performance and Scalability 206
The Scale of Mobile 207
Persistence in the Cloud: From SQL to NoSQL 208
Database File Format 211
NoSQL Persistence 213
Design Considerations for Scalable Persistence 215
To SQL or Not to SQL? 215
Looking at Popular Cloud Providers 218
Amazon AWS 218
Google App Engine 219
Joyent: Hosted MongoDB+node.js 219
Red Hat OpenShift 220
Exploring the Code Examples 220
The Contacts DAO Interface (Again) 221
Writing the Code: Amazon Contacts Service 221
Writing the Code: Google App Engine Contacts 235
Summary 243
PIM Databases: Fossils from Smartphone Pre-History 246
Android’s Contacts Provider 246
The ContactsContract API 246
A Contacts Provider Explorer 247
Code for Exploring a Database 249
Source Code for a Contacts Provider Explorer 249
Summary 262
Introducing WebData and Project Migrate 266
How Project Migrate Works 266
How Project Migrate Streamlines the Mobile Connection
to the Enterprise 267
The WebData API in Detail 268
The WebData API RESTful Protocol 269
Project Migrate in Detail 279
The Migrate Project Android WebData Client 279
Project Migrate Android Features 279
ftoc.indd xviftoc.indd xvi 26-09-2013 19:12:5926-09-2013 19:12:59
The WebData Content Provider Android API 281
Android Built-In Provider APIs 281
The Migrate Provider API 281
Summary 281
Service-Side Advantages 282
Client Advantages 282
The Migrate Client 284
Creating a Migrate Project 285
Step 1: Importing the Project 285
Step 2: Enabling the Project as a Migrate Client 285
Step 3: Defi ning the Information to Be Managed by Migrate 286
Step 4: Generating the Contacts Contract 287
Interfacing with the Migrate REST Proxy 291
Step 5: Starting a Local Migrate Service 296
Step 6: Publishing Your Application’s Schema 296
Setting Up a Device 298
Step 1: Installing the Migrate Client 298
Step 2: Adding a WebData Account 299
Step 3: Turning on Synchronization 299
Step 4: Running the Application 300
Step 5: Confi guring an Account in Migrate Contacts (Optional) 300
Future Directions: MigrateClinic 300
Summary 303
Modularity and Flexibility Compared
with a “Cookbook” Approach 306
Overview of Modules 306
Layout Changes 307
Direct Manipulation 308
The TabbedActivity Class 308
The TabbedPagedFragment Class 319
Navigation 320
Multitasking in a Small-Screen Environment 320
The Android Task Model 320
Tasks and the Conventional Process Model 321
Modifying Task Behavior 321
Navigation in Tablets 323
Choosing to Use the Support Package 323
Summary 324
ftoc.indd xviiftoc.indd xvii 26-09-2013 19:12:5926-09-2013 19:12:59
Platform Security 326
Keeping Handsets Safe 327
Avoiding Malicious Applications 327
Understand Malware Mechanics: The Malware Genome 330
Writing Secure Applications 331
Hacking Targets 331
Ingredients of a Secure Application 332
Example Code: Protecting RESTful Invocations 353
Preventing Piracy 365
Summary 366
ftoc.indd xviiiftoc.indd xviii 26-09-2013 19:12:5926-09-2013 19:12:59
MANY ENTERPRISE-ORIENTED APPLICATIONS t a broad template: They access data using one or
more RESTful APIs. They present the data to the user. They may enable the user to modify the data,
and update the data on servers. Enterprise Android is a book about those applications.
If you are an experienced Java or JavaScript coder, you may have some ideas about how RESTful
apps should work. You can correctly think of Android as a Java OS: You write apps in Java and
deploy them to an environment that, in some ways, very closely resembles a Java VM. These apps
communicate with RESTful APIs to fetch data to present to the user.
But, as with many aspects of Android software development, it pays to look at how Android is
designed before wading in. This book was created to give you a substantial head start at applying
your experience with RESTful applications and APIs to creating Android apps that are ef cient,
versatile, and responsive. You will avoid the pitfalls of assuming Android programming is like web
programming or client Java programming using Oracle’s class libraries, and be able to do it using
Android APIs effectively on the  rst try.
If you are a beginning Android programmer, and do not have signi cant experience with iOS or Java,
or if you are unsure that RESTful applications are what you need to learn about, you should start with
a general introduction to Android. Beginners will appreciate a book like Reto Meier’s excellent
Professional Android 4 Application Development (John Wiley & Sons, 2012) or the online tutorials
at, which are much improved compared to the early days of Android.
If you are interested in expanding your development horizon beyond device programming by push-
ing into service-side development, this book builds competence handling application data on both
sides of the network.
This book starts with the basics of creating an Enterprise-oriented Android app that can run on
handsets and tablets. But it’s not a beginner’s book. You should, at least, read the online tutorials at
Google’s Android Developer’s site before reading this book.
Android uses SQLite, and this book covers SQL and SQLite in enough depth that you will
understand how data is stored in SQLite databases in Android systems.
Android wraps SQLite in database classes, and this book covers those classes in depth, as well.
When apps make use of data in the Android environment, they often use a specialized service
component called a
ContentProvider. This class, and the related ContentResolver class, provide
a REST-like interface to data within an Android device. Using these classes has other advantages in
building apps that use the observer pattern.
flast.indd xixflast.indd xix 26-09-2013 22:37:2026-09-2013 22:37:20
Enabling you to implement an end-to-end observer pattern is a key element of this book. Your data
resides in a database behind a RESTful API on your servers. Locally, it is likely to be stored in a
SQLite database inside a
ContentProvider component. This book shows you how to make sure the
data you present to the user is consistent and up to date.
Simplicity is important, too. JSON is a simple way to represent data with simplicity and  exibility
where, otherwise, a complex database design might be required. This book shows you how to use JSON
with SQLite to maintain simplicity in your implementation. It also shows you a complex Android data-
base and
ContentProvider interface, implemented with a conventional approach to database design.
You will create and deploy a server for your front end as you use the examples in this book. In
particular, Chapters 5 and 6 come together at the end of Chapter 6 to form an end-to-end example
of the techniques covered in this book. You’ll deploy this service on Amazon and Google cloud
resources in Chapter 7.
One thing you won’t spend much time on is loading indicators. A networked app should be as respon-
sive as a “local” app. Create, update, and delete (CRUD) should not be interposed between the user and
the data the user wants. A very important part of this book explains how to keep CRUD off the net-
work and out of the user’s way, using a lightweight but powerful synchronization protocol. The book
completes this approach by introducing an open source framework that encapsulates this approach.
The book concludes with an in-depth tour of Android security.
This book is called Enterprise Android because it is about acquiring, presenting, and updating data
on devices and using cloud resources, which is the core of most enterprise applications.
This book starts with a brisk-paced introduction to Android programming that puts you on track to make
an application for displaying data. This is about as fast an introduction as can be, so don’t be surprised if
you need to go to the online tutorials in the Android documentation to go deeper on some basics.
Following this introduction, you will be immersed in the core subject matter of this book: data. The
book progresses from the bottom up: how to store data locally, how to make queries, how to get it
and serve it from REST APIs, how the observer pattern is implemented in Android idioms, how to
update it, and how to make this all happen with or without connectivity and with the best apparent
performance. Later in the book, more UI programming oriented toward presenting data is covered.
The book closes with a chapter on security.
This book is about Android software development, and the examples in it require the use of the
Android software development kit (SDK), which is available from The
SDK is compatible with the three most widely used desktop operating systems: Windows, Mac OS
X, and Linux. You may prefer to use an Android device to run the example code, but you can use an
emulator, included in the SDK, running on your desktop computer.
flast.indd xxflast.indd xx 26-09-2013 22:37:2026-09-2013 22:37:20
NOTE Database code in Android has been very stable for several versions of
the Android OS. Mostly due to the way we cover user interface for database
apps, this book assumes you will run your programs on Android 4 or later
versions. You can expect most of this book to remain current for future version
of Android.
To run the service examples in the book, you’ll need to download the packages in each chapter,
including the following: Apache Tomcat, ant, MySQL, and the cygwin toolkit. You’ll also need
an Amazon AWS account with manager privileges and a Google account.
To help you get the most from the text and keep track of what’s happening, you’ll see a number of
conventions throughout the book.
WARNING Warnings like this one hold important, not-to-be forgotten informa-
tion that is directly relevant to the surrounding text.
NOTE Notes offer tips, hints, tricks, and asides to the current discussion.
As for styles in the text:
New terms and important words are highlighted when they are introduced.
Keyboard strokes appear like this: Ctrl+A.
Filenames, URLs, and code within the text appear like so:
Code appears in two different ways:
We use a monofont type with no highlighting for most code examples.
We use bold to emphasize code that’s particularly important in the present context.
As you read the chapters in this book, you will want to run, inspect, and perhaps modify the source
code  les that accompany the book. Please note that all the code examples in this chapter are avail-
able at and as a part of the
books code download at on the Download Code tab.
flast.indd xxiflast.indd xxi 26-09-2013 22:37:2126-09-2013 22:37:21
To nd the source code via the Wrox site, locate the books title (either by using the Search box or
by using one of the title lists) and click the Download Code link on the books detail page to obtain
all the source code for the book.
NOTE Because many books have similar titles, you may  nd it easiest to search
by ISBN; this book’s ISBN is 978-1-118-18349-6
Alternately, you can go to the main Wrox code download page at
to see the code available for this book and all other Wrox books.
We make every effort to ensure that there are no errors in the text or in the code. However, no one
is perfect, and mistakes do occur. If you  nd an error in one of our books, like a spelling mistake or
faulty piece of code, we would be very grateful for your feedback. By sending in errata you may save
another reader hours of frustration and at the same time you will be helping us provide even higher
quality information.
To nd the errata page for this book, go to and locate the title using the Search
box or one of the title lists. Then, on the book details page, click the Book Errata link. On this page
you can view all errata that has been submitted for this book and posted by Wrox editors.
NOTE A complete book list including links to each book’s errata is also available
If you dont spot “your” error on the Book Errata page, go to
and complete the form there to send us the error you have found. We’ll check the information
and, if appropriate, post a message to the books errata page and  x the problem in subsequent edi-
tions of the book.
For author and peer discussion, join the P2P forums at The forums are a web-based
system for you to post messages relating to Wrox books and related technologies and interact with
other readers and technology users. The forums offer a subscription feature to e-mail you topics
of interest of your choosing when new posts are made to the forums. Wrox authors, editors, other
industry experts, and your fellow readers are present on these forums.
flast.indd xxiiflast.indd xxii 26-09-2013 22:37:2126-09-2013 22:37:21
At you will  nd a number of forums that will help you not only as you read
this book, but also as you develop your own applications. To join the forums, just follow these steps:
1. Go to and click the Register link.
2. Read the terms of use and click Agree.
3. Complete the required information to join as well as any optional information you wish to
provide and click Submit.
4. You will receive an e-mail with information describing how to verify your account and com-
plete the joining process.
NOTE You can read messages in the forums without joining P2P, but in order to
post your own messages, you must join.
Once you join, you can post new messages and respond to messages other users post. You can read
messages at any time on the web. If you would like to have new messages from a particular forum
e-mailed to you, click the Subscribe to this Forum icon by the forum name in the forum listing.
For more information about how to use the Wrox P2P, be sure to read the P2P FAQs for answers to
questions about how the forum software works as well as many common questions speci c to P2P
and Wrox books. To read the FAQs, click the FAQ link on any P2P page.
flast.indd xxiiiflast.indd xxiii 26-09-2013 22:37:2126-09-2013 22:37:21
flast.indd xxivflast.indd xxiv 26-09-2013 22:37:2126-09-2013 22:37:21
Developing for Android
Tablets and Smartphones
Getting your tools set up
Testing your tools setup
What a modern Android application looks like
Introducing a concise application framework that works on all sizes
of Android devices
Exploring Android component lifecycles and the Android task model
Please note that all the code examples in this chapter are available at
and as a part of the books code download at on the Download Code tab. At various points throughout the book, the
authors refer to the “Examples” directory using a pseudo-variable called, “CODE”. Readers
can either explicity set this value as a shell variable or can just keep in mind that the variable
refers to the book example code directory.
This book is about best practices in handling data for enterprise application across the client
and RESTful backend services, and this chapter gets you through the basics at a brisk pace
while providing a framework, which is the starting point for the example code in this book.
The advice in this chapter, especially the advice to pay attention to Android component
lifecycles, will enable you to complete an Android coding project ef ciently, without having to
know everything about Android, and with a minimum of grief.
Many Android books were written before there were Android tablet devices, and before the
APIs central to creating good UIs for those devices were a mainstream concern for Android
developers. This chapter starts by assuming your apps will run on both tablets and handsets
and provides a framework that embodies the best practices for doing so.
c01.indd 1c01.indd 1 26-09-2013 19:04:0526-09-2013 19:04:05
This chapter also covers tools — and knowledge resources for the tools that you need to follow
the code examples in this book.
This isn’t a beginner’s book. If this is your  rst time programming Android applications, use the
information resources listed here for  lling in the gaps in your knowledge of and experience with
Java and Android programming.
Almost all applications and all system services in Android are coded in Java (and other JVM
languages). Code is compiled to Java bytecode before being translated into Dalvik bytecode, which,
in turn, runs in the Android managed runtime environment. These characteristics make Android
at once familiar and strange: If you have used Java or a similar managed language before, you will
nd Android code fairly easy to read. You will  nd the tools for Android programming familiar.
Many aspects of Android’s managed language run time are identical to Java. Android relies on Java
base classes, and wouldn’t work if the semantics of the Android runtime environment were not very
similar to those of a standard Java runtime environment.
If you come to this book not having written Android-speci c code, you have probably never written
code for an operating system like Android. Android uses managed language runtime concepts in
ways you may  nd unfamiliar, especially in the ways Android implements modularity and memory
management. In many ways, Android is the most sophisticated environment for interactive Java
programs ever created.
WARNING Pay close attention to the basics of Android application program-
ming and follow the key practices described in this chapter. If you try to impose
your coding practices from server Java or MIDlets, or attempt to thwart the way
the Android system works with applications, bugs and frustration will result.
This section covers setting up your programming tools. You will run your  rst example application,
which is a user interface framework.
Prerequisites and Getting Ready
You can use any of the three major operating systems for PCs to develop Android software: Linux,
Mac OS, or Windows. You will need three independent pieces to assemble your toolchain for
creating Android applications: The Java JDK, Eclipse, and the Android SDK. All three of these
pieces work on all three operating systems.
The place to  nd reference information on developing Android is
and the place to get started with instructions on installing your tool set is http://developer
c01.indd 2c01.indd 2 26-09-2013 19:04:0626-09-2013 19:04:06
Your Tools and Your First Android App
Follow the instructions at the URL to install the tools you need. If you follow the instructions
correctly, you will install a toolchain consisting of the three pieces listed previously.
Java and Java Knowledge
The  rst piece of the tool set you need is the Java Development Kit, or JDK. The JDK provides
both a Java runtime environment, which is needed by Eclipse, and some tools for creating Android
Java is a cross-platform runtime environment and is the key to developing Android software on any
of the top three personal computer operating systems.
You will write your Android programs in Java, even though the runtime environment in the Android
operating system is internally substantially different from Java runtime environments. Although you
don’t need to know the details of the way your programming tools are implemented using Java,
you have to know Java to write Android programs. There are numerous tutorials on the web and
books to help you learn Java. One free resource for learning Java is Oracle’s Java Tutorials site:
Eclipse and Eclipse Knowledge
Eclipse is the integrated development environment (IDE) you will be using. An IDE is an all-in-one
software development tool that enables you to create source code with correct syntax and style, run
that code, and examine and debug it if you need to  nd out why it isn’t working correctly. As you
create Android software, you will spend most of your time using the Eclipse IDE.
Eclipse is a Java program and it uses the Java run time in the JDK you installed to run on your
personal computer. Eclipse is widely used for many kinds of programming, including creating Java-
based server software for the kinds of applications described in this book.
The use of Eclipse is one of the reasons Android was born with a mature toolchain. You write
Android programs using the Java language, and most of the toolchain for writing “normal” Java
programs can be applied to Android.
Eclipse enables you to edit your code while providing quick access to documentation. It enhances
productivity through automatic completion of symbols and automatic formatting. It helps you  nd
syntax errors, and it performs static analysis that  nds potential runtime errors. It also enables
you to inspect running applications, stop them, single-step across code that corresponds to lines
of source code, inspect variables, examine unhandled exceptions, and perform dozens of other
operations that will improve your productivity in creating Android applications.
Knowing your IDEs features is key to productivity and to avoiding frustration when programs
don’t work. This is especially true for Eclipse, which is very powerful and has many more useful
tools available for it than listed here, but it isn’t as simple as some other IDEs, such as Apple’s
IDE for iOS development. So it is likely you will need to become more familiar with Eclipse
if you are a  rst-time user. Tutorials on Eclipse can be found at
. To run all the examples in this book, you will need to download
and install Eclipse IDE for Java EE Developers.
c01.indd 3c01.indd 3 26-09-2013 19:04:0626-09-2013 19:04:06
The Android SDK and Resources for Android Tools Knowledge
The third part of your toolchain is the Android Software Development Kit (SDK). The SDK is
documented in Google’s online documentation for Android developers at
The SDK turns the Eclipse IDE into an IDE that can create Android programs. The SDK provides
plugins for Eclipse and many external components that are used to create Android applications and
diagnose problems in Android software. Eclipse can be adapted to many purposes with plugins.
In fact, Eclipse is made almost entirely of plugins. The set of plugins you started with when you
installed Eclipse make Eclipse suitable for creating Java programs. For the purposes of this book,
you will mostly work in the Eclipse IDE, and all you need to do at this point is to con gure Eclipse
to use the Android plugins and to be able to locate other programs installed with the SDK. You will
be prompted to do so when you start Eclipse after the Android SDK is installed.
Now you have all the tools for general Android programming, and for this chapter. Later in this
book, other tools speci c to topics introduced in those chapters will be added to your toolchain.
Toolchain Test Drive
You can test that your toolchain is installed correctly by creating a new Android project, and
selecting an example from the SDK as the basis of your project. You should be able to run your
project in an Android Virtual Device (AVD).
Directions for creating a project are here:
Directions for running a project are here:
By doing this, you have created an Android project in Eclipse, and created and run an Android
application, even though you have not written any code yet. If you are successful in doing this, you
can be con dent your toolchain and the software it depends on have been correctly installed. The
next section describes how to download and use the example code in this chapter to create another
Android project. But you might want to explore your toolchain at this point.
NOTE One thing you might want to do is create more Android projects based on
the example code using the option in the New Project wizard to select example
This section introduces the  rst code that is speci c to this book. This framework is used to
illustrate some important points about Android application fundamentals, to get you used to the
tools you just installed, and to provide a quick way to start writing application-speci c code rather
c01.indd 4c01.indd 4 26-09-2013 19:04:0626-09-2013 19:04:06