Beginning Android 4 (Unknown) (z-library.sk, 1lib.sk, z-lib.sk)

For your convenience Apress has placed some of the front matter material after the index. Please use the Bookmarks and Contents at a Glance links to access them. D ow nl oa d fr om W ow ! e B oo k < w w w .w ow eb oo k. co m >

iii Contents at a Glance Contents .............................................................................................................. v About the Authors ............................................................................................ xvii About the Technical Reviewer ........................................................................ xviii Acknowledgments ............................................................................................ xix Preface .............................................................................................................. xx Part I: Core Concept ............................................................................................ 1 ■Chapter 1: The Big Picture ............................................................................... 3 ■Chapter 2: How to Get Started ......................................................................... 7 ■Chapter 3: Your First Android Project ........................................................... 23 ■Chapter 4: Examining Your First Project ....................................................... 31 ■Chapter 5: A Bit About Eclipse ....................................................................... 37 ■Chapter 6: Enhancing Your First Project ....................................................... 47 Part II: Activities ............................................................................................... 51 ■Chapter 7: Rewriting Your First Project ........................................................ 53 ■Chapter 8: Using XML-Based Layouts ........................................................... 57 ■Chapter 9: Employing Basic Widgets ............................................................. 63 ■Chapter 10: Working with Containers ........................................................... 79 ■Chapter 11: The Input Method Framework .................................................. 103 ■Chapter 12: Using Selection Widgets .......................................................... 113 ■Chapter 13: Getting Fancy with Lists .......................................................... 129 ■Chapter 14: Still More Widgets and Containers ........................................... 145 ■Chapter 15: Embedding the WebKit Browser .............................................. 169 ■Chapter 16: Applying Menus ....................................................................... 177 ■Chapter 17: Showing Pop-Up Messages ...................................................... 189 ■Chapter 18: Handling Activity Lifecycle Events ........................................... 193 ■Chapter 19: Handling Rotation .................................................................... 197 ■Chapter 20: Dealing with Threads ............................................................... 213

■ CONTENTS AT A GLANCE iv ■Chapter 21: Creating Intent Filters .............................................................. 231 ■Chapter 22: Launching Activities and Subactivities .................................... 237 ■Chapter 23: Working with Resources .......................................................... 245 ■Chapter 24: Defining and Using Styles ........................................................ 263 Part III: Honeycomb and Tablets ..................................................................... 269 ■Chapter 25: Handling Multiple Screen Sizes ............................................... 271 ■Chapter 26: Focusing on Tablets and Larger UIs ......................................... 293 ■Chapter 27: Using the Action Bar ................................................................ 299 ■Chapter 28: Fragments ................................................................................ 307 ■Chapter 29: Handling Platform Changes ..................................................... 323 Part IV: Data Stores, Network Services, and APIs .......................................... 333 ■Chapter 30: Accessing Files ........................................................................ 335 ■Chapter 31: Using Preferences .................................................................... 349 ■Chapter 32: Managing and Accessing Local Databases .............................. 367 ■Chapter 33: Leveraging Java Libraries ....................................................... 381 ■Chapter 34: Communicating via the Internet .............................................. 389 Part V: Services .............................................................................................. 407 ■Chapter 35: Services: The Theory ................................................................ 409 ■Chapter 36: Basic Service Patterns ............................................................. 417 ■Chapter 37: Alerting Users via Notifications ............................................... 437 Part VI: Other Android Capabilities ................................................................. 449 ■Chapter 38: Requesting and Requiring Permissions ................................... 451 ■Chapter 39: Accessing Location-Based Services ........................................ 457 ■Chapter 40: Mapping with MapView and MapActivity ................................ 463 ■Chapter 41: Handling Telephone Calls ......................................................... 477 ■Chapter 42: Fonts ........................................................................................ 481 ■Chapter 43: More Development Tools ......................................................... 487 Part VII: Alternative Application Environments .............................................. 505 ■Chapter 44: The Role of Alternative Environments ...................................... 507 ■Chapter 45: HTML5 ...................................................................................... 511 ■Chapter 46: PhoneGap ................................................................................. 525 ■Chapter 47: Other Alternative Environments ............................................... 543 Part VIII: The Ever-Evolving Android .............................................................. 549 ■Chapter 48: Dealing with Devices ................................................................ 551 ■Chapter 49: Where Do We Go from Here? .................................................... 557 Index ............................................................................................................... 561

Part Core Concept I

3 Chapter The Big Picture Android is everywhere. Phones. Tablets. TVs and set-top boxes powered by Google TV. Soon, Android will be in cars, in in-flight entertainment systems on planes, and even in robots! However, the general theme of Android devices will be smaller screens and/or no hardware keyboard. And, by the numbers, Android will probably be associated mostly with smartphones for the foreseeable future. For developers, this has both benefits and drawbacks, as described next. This chapter also describes the main components in an Android application and the Android features that you can exploit when developing your applications. Benefits and Drawbacks of Smartphone Programming On the plus side, Android-style smartphones are sexy. Offering Internet services over mobile devices dates back to the mid-1990s and the Handheld Device Markup Language (HDML). However, only in recent years have phones capable of Internet access taken off. Now, thanks to trends like text messaging and products like Apple’s iPhone, phones that can serve as Internet-access devices are rapidly gaining popularity. So, working on Android applications gives you experience with an interesting technology (Android) in a fast-moving market segment (Internet-enabled phones), which is always a good thing. The problem comes when you actually have to program the darn things. Anyone with experience in programming for PDAs or phones has felt the pain of phones simply being small in all sorts of dimensions: Screens are small (you will not get comments like, “Is that a 24-inch LCD in your pocket, or . . . ?”). Keyboards, if they exist, are small. 1

CHAPTER 1: The Big Picture 4 Pointing devices, if they exist, are annoying (as anyone who has lost their stylus will tell you) or inexact (large fingers and “multitouch” LCDs can sometimes be . . . problematic). CPU speed and memory are always behind what’s available on desktops and servers. Moreover, applications running on a phone have to deal with the fact that they’re on a phone. People with mobile phones tend to get very irritated when those phones do not work. Similarly, those same people will get irritated if your program “breaks” their phones by Tying up the CPU such that calls can’t be received. Not quietly fading into the background when a call comes in or needs to be placed, because the program doesn’t work properly with the rest of the phone’s operating system. Crashing the phone’s operating system, such as by leaking memory like a sieve. Hence, developing programs for a phone is a different experience than developing desktop applications, web sites, or back-end server processes. The tools look different, the frameworks behave differently, and you have more limitations on what you can do with your programs. What Android tries to do is meet you halfway: You get a commonly used programming language (Java) with some commonly used libraries (e.g., some Apache Commons APIs), with support for tools you may be used to using (Eclipse). You get a fairly rigid and uncommon framework in which your programs need to run so they can be “good citizens” on the phone and not interfere with other programs or the operation of the phone itself. As you might expect, much of this book deals with that framework and how you write programs that work within its confines and take advantage of its capabilities. What Androids Are Made Of When you write a desktop application, you are “master of your own domain.” You launch your main window and any child windows—like dialog boxes—that are needed. From your standpoint, you are your own world, leveraging features supported by the operating system, but largely ignorant of any other program that may be running on the computer at the same time. If you do interact with other programs, it is typically through an application programming interface (API), such as Java Database Connectivity (JDBC), or frameworks atop it, to communicate with MySQL or another database.

CHAPTER 1: The Big Picture 5 Android has similar concepts, but they are packaged differently and structured to make phones more crash-resistant: Activities: The building block of the user interface is the activity. You can think of an activity as being the Android analogue for the window or dialog box in a desktop application or the page in a classic web application. Android is designed to support lots of cheap activities, so you can allow users to keep tapping to open new activities and tapping the Back button to back up, just like they do in a web browser. Services: Activities are short-lived and can be shut down at any time. Services, on the other hand, are designed to keep running, if needed, independent of any activity, akin to the notion of services or daemons on other operating systems. You might use a service to check for updates to an RSS feed or to play back music even if the controlling activity is no longer operating. You will also use services for scheduled tasks (“cron jobs”) and for exposing custom APIs to other applications on the device, though those are relatively advanced capabilities. Content providers: Content providers provide a level of abstraction for any data stored on the device that is accessible by multiple applications. The Android development model encourages you to make your own data available to other applications, as well as your own applications. Building a content provider lets you do that, while maintaining complete control over how your data gets accessed. Content providers can be anything from web feeds, to local SQLite databases, and beyond. Intents: Intents are system messages that run around the inside of the device and notify applications of various events, from hardware state changes (e.g., an SD card was inserted), to incoming data (e.g., a Short Message Service [SMS] message arrived), to application events (e.g., your activity was launched from the device’s main menu). Intents are much like messages or events on other operating systems. Not only can you respond to an Intent, but you can create your own to launch other activities or to let you know when specific situations arise (e.g., raise such-and-so Intent when the user gets within 100 meters of this-and-such location). Stuff at Your Disposal Storage: You can package data files with your application for things that do not change, such as icons or help files. You also can carve out a small bit of space on the device itself, for databases or files containing user-entered or retrieved data needed by your application. And, if the user supplies bulk storage, like an SD card, you can read and write files on there as needed.

CHAPTER 1: The Big Picture 6 Network: Android devices generally are Internet-ready, through one communications medium or another. You can take advantage of the Internet access at any level you wish, from raw Java sockets all the way up to a built-in WebKit-based web browser widget you can embed in your application. Multimedia: Android devices have the ability to play back and record audio and video. While the specifics may vary from device to device, you can query the device to learn its capabilities and then take advantage of the multimedia capabilities as you see fit, whether that is to play back music, take pictures with the camera, or use the microphone for audio note-taking. Location services: Android devices frequently have access to location providers, such as GPS and cell triangulation, which can tell your applications where the device is on the face of the Earth. In turn, you can display maps or otherwise take advantage of the location data, such as to track a device’s movements if the device has been stolen. Phone services: Because Android devices are typically phones, your software can initiate calls, send and receive SMS messages, and do everything else you expect from a modern bit of telephony technology. The Big Picture...of This Book Now that you have the Android big picture, here is what’s coming in the rest of this book: The next two chapters are designed to get you going quickly with the Android environment, through a series of step-by-step, tutorial-style instructions for setting up the tools you need, creating your first project, and getting that first project running on the Android emulator. The three chapters that follow explain a bit more about what just happened in Chapters 2 and 3. We examine the Android project that we created, talk a bit more about Eclipse, and discuss some things we could add to the project to help it run on more devices and enhance its capabilities. The bulk of the book explores the various capabilities of the Android APIs—how to create components like activities, how to access the Internet and local databases, how to get your location and show it on a map, and so forth.

7 Chapter How to Get Started Without further ado, let’s get you set up with the pieces and parts necessary to build an Android app. NOTE: The instructions presented here are accurate as of the time of this writing. However, the tools change rapidly, so these instructions may be out of date by the time you read this. Please refer to the Android Developers web site for current instructions, using this as a base guideline of what to expect. Step 1: Set Up Java When you write Android applications, you typically write them in Java source code. That Java source code is then turned into the stuff that Android actually runs (Dalvik bytecode in an Android package [APK] file). Hence, the first thing you need to do is get set up with a Java development environment so that you are prepared to start writing Java classes. Install the JDK You need to obtain and install the official Oracle Java SE Development Kit (JDK). You can obtain this from the Oracle Java web site for Windows and Linux, and from Apple for Mac OS X. The plain JDK (sans any “bundles”) should suffice. Follow the instructions supplied by Oracle or Apple for installing it on your machine. At the time of this writing, Android supports Java 5 and Java 6, with Java 7 likely to be supported by the time you are reading this. 2

CHAPTER 2: How to Get Started 8 ALTERNATIVE JAVA COMPILERS In principle, you are supposed to use the official Oracle JDK. In practice, it appears that OpenJDK also works, at least on Ubuntu. However, the further removed you get from the official Oracle implementation, the less likely it is that it will work. For example, the GNU Compiler for Java (GCJ) may not work with Android. Learn Java This book, like most books and documentation on Android, assumes that you have basic Java programming experience. If you lack this, you really should consider spending a bit of time on Java fundamentals before you dive into Android. Otherwise, you may find the experience to be frustrating. If you are in need of a crash course in Java to get involved in Android development, here are the concepts you need to learn, presented in no particular order: Language fundamentals (flow control, etc.) Classes and objects Methods and data members Public, private, and protected Static and instance scope Exceptions Threads and concurrency control Collections Generics File I/O Reflection Interfaces One of the easiest ways of acquiring this knowledge is to read Learn Java for Android Development by Jeff Friesen (Apress, 2010).

CHAPTER 2: How to Get Started 9 Step 2: Install the Android SDK The Android SDK gives you all the tools you need to create and test Android applications. It comes in two parts: the base tools, and version-specific SDKs and related add-ons. Install the Base Tools You can find the Android developer tools on the Android Developers web site at http://developer.android.com. Download the ZIP file that is appropriate for your platform and unzip it in a logical location on your machine—no specific path is required. Windows users also have the option of running a self-installing EXE file. Install the SDKs and Add-ons Inside the tools/ directory of your Android SDK installation from the previous step, you will see an android batch file or shell script. If you run that, you will be presented with the Android SDK and AVD Manager, shown in Figure 2–1. Figure 2–1. Android SDK and AVD Manager At this point, you have some of the build tools, but you lack the Java files necessary to compile an Android application. You also lack a few additional build tools, and the files necessary to run an Android emulator. To address this, click the Available packages option on the left to open the screen shown in Figure 2–2. D ow nl oa d fr om W ow ! e B oo k < w w w .w ow eb oo k. co m >

CHAPTER 2: How to Get Started 10 Figure 2–2. Android SDK and AVD Manager available packages Open the Android Repository branch of the tree. After a short pause, you will see a screen similar to Figure 2–3. Figure 2–3. Android SDK and AVD Manager available Android packages Check the boxes for the following items: “SDK Platform” for all Android SDK releases you want to test against “Documentation for Android SDK” for the latest Android SDK release “Samples for SDK” for the latest Android SDK release, and perhaps for older releases if you wish Then, open the Third party Add-ons branch of the tree. After a short pause, you will see a screen similar to Figure 2–4.

CHAPTER 2: How to Get Started 11 Figure 2–4. Android SDK and AVD Manager available third-party add-ons Click the “Google Inc. add-ons” branch to open it, as shown in Figure 2–5. Figure 2–5. Android SDK and AVD Manager available Google add-ons Most likely, you will want to check the boxes for the “Google APIs by Google Inc.” items that match up with the SDK versions you selected in the Android Repository branch. The Google APIs include support for well-known Google products, such as Google Maps, both from your code and in the Android emulator. After you have checked all the items you want to download, click the Install Selected button, which brings up a license confirmation dialog box, shown in Figure 2–6.

CHAPTER 2: How to Get Started 12 Figure 2–6. Android SDK and AVD Manger license agreement screen Review and accept the licenses if you agree with the terms, and then click the Install button. At this point, this is a fine time to go get lunch or dinner. Unless you have a substantial Internet connection, downloading all of this data and unpacking it will take a fair bit of time. When the download is complete, you can close the SDK and AVD Manager if you wish, though you will use it to set up the emulator in Step 5 of this chapter. Step 3: Install the ADT for Eclipse If you will not be using Eclipse for your Android development, you can skip to the next section. If you will be using Eclipse but have not yet installed it, you will need to do that first. Eclipse can be downloaded from the Eclipse web site, www.eclipse.org/. The Eclipse IDE for Java Developers package will work fine. Next, you need to install the Android Developer Tools (ADT) plug-in. To do this, open Eclipse and choose Help ➤➤ Install New Software. Then, in the Install dialog box, click the Add button to add a new source of plug-ins. Give it a name (e.g., Android) and supply the following URL: https://dl-ssl.google.com/android/eclipse/. That should trigger Eclipse to download the roster of plug-ins available from that site (see Figure 2–7).

CHAPTER 2: How to Get Started 13 Figure 2–7. Eclipse ADT plug-in installation Check the Developer Tools check box and click the Next button. Follow the rest of the wizard steps to review the tools to be downloaded and review and accept their respective license agreements. When the Finish button is enabled, click it, and Eclipse will download and install the plug-ins. When it’s done, Eclipse will ask to restart; let it do so. Then, you need to show ADT where to locate your Android SDK installation from the preceding section. To do this, choose Window ➤➤ Preferences from the Eclipse main menu (or the equivalent Preferences option for Mac OS X). Click the Android entry in the list pane of the Preferences dialog box, as shown in Figure 2–8.

CHAPTER 2: How to Get Started 14 Figure 2–8. Eclipse ADT configuration Then, click the Browse button to find the directory where you installed the SDK. After choosing it, click Apply in the Preferences dialog box, and you should see the Android SDK versions you installed previously. Then, click OK, and the ADT will be ready for use. Step 4: Install Apache Ant If you will be doing all of your development from Eclipse, you can skip to the next section. If you wish to develop using command-line build tools, you need to install Apache Ant. You may have this installed already from previous Java development work, as it is fairly common in Java projects. However, you need Ant version 1.8.1 or later, so check your current copy (e.g., ant -version). If you do not have Ant or do not have the correct version, you can obtain it from the Apache Ant web site, at http://ant.apache.org/. Full installation instructions are available in the Ant manual, but the basic steps are as follows: 1. Unpack the ZIP archive in a logical place on your machine. 2. Add a JAVA_HOME environment variable, pointing to where your JDK is installed, if you do not have one already. 3. Add an ANT_HOME environment variable, pointing to the directory where you unpacked Ant in step 1. 4. Add $JAVA_HOME/bin and $ANT_HOME/bin to your PATH. 5. Run ant -version to confirm that Ant is installed properly.

CHAPTER 2: How to Get Started 15 Step 5: Set Up the Emulator The Android tools include an emulator, a piece of software that pretends to be an Android device. This is very useful for development because it not only enables you to get started on your Android development without a device, but also enables you to test device configurations for devices that you do not own. The Android emulator can emulate one or several Android devices. Each configuration you want is stored in an Android Virtual Device (AVD). The Android SDK and AVD Manager, which you used to download the SDK components earlier in this chapter, is where you create these AVDs. If you do not have the SDK and AVD Manager running, you can run it via the android command from your SDK’s tools/ directory, or via Window ➤ SDK and AVD Manager from Eclipse. It opens with a screen listing the AVDs you have available; initially, the list will be empty, as shown in Figure 2–9. Figure 2–9. Android SDK and AVD Manager Android Virtual Devices list Click the New button to create a new AVD file. This opens the dialog box shown in Figure 2–10, where you can configure how this AVD should look and work.

CHAPTER 2: How to Get Started 16 Figure 2–10. Adding a new AVD You need to provide the following: A name for the AVD: Since the name goes into files on your development machine, you are limited by the file name conventions for your operating system (e.g., no backslashes on Windows). The Android version (target) you want the emulator to run: Choose one of the SDKs you installed via the Target drop-down list. Note that in addition to “pure” Android environments, you will have options based on the third-party add-ons you selected. For example, you probably have some options for setting up AVDs containing the Google APIs, and you will need such an AVD for testing an application that uses Google Maps. Details about the SD card the emulator should emulate: Since Android devices invariably have some form of external storage, you probably want to set up an SD card, by supplying a size in the associated field. However, since a file will be created on your development machine of whatever size you specify for the card, you probably do not want to create a 2GB emulated SD card. 32MB is a nice starting point, though you can go larger if needed.

CHAPTER 2: How to Get Started 17 The “skin” or resolution the emulator should run in: The skin options you have available depend upon what target you chose. The skins let you choose a typical Android screen resolution (e.g., WVGA800 for 800 480). You can also manually specify a resolution when you want to test a nonstandard configuration. You can skip the Hardware section of the dialog box for now, as changing those settings is usually only required for advanced configurations. The resulting dialog box might look something like Figure 2–11. Figure 2–11. Adding a new AVD (continued) Click the Create AVD button, and your AVD stub will be created. To start the emulator, select it in the Android Virtual Devices list and click Start. You can skip the launch options for now and just click Launch. The first time you launch a new AVD, it will take a long time to start up. The second and subsequent times you start the AVD, it will come up a bit faster, and usually you need to start it only once per day (e.g., when you start development). You do not need to stop and restart the emulator every time you want to test your application, in most cases. The emulator will go through a few startup phases, the first of which displays a plain-text ANDROID label, as shown in Figure 2–12.