What readers are saying about Hello, Android This is a most excellent book: very well written, easy to read, and fun. In addition, any of Android’s quirks are explained along with just the right amount of detail to ensure quality programming principles are followed. Anthony Stevens Founder and CTO, PocketJourney and Top 20 Winner of Google Android Competition Ed Burnette covers an impressive amount of ground in a nicely com- pact book while retaining the popular Pragmatic style. For the mate- rial on 2D and 3D graphics alone, this is worthy of a spot in any Android developer’s library. Mark Murphy Founder, CommonsWare I remember when I first started to work with Android; it was like a huge maze. With this book, the introduction would have been much less painful. I am convinced that by reading this book new Android programmers will have an easier start. Gabor Paller Senior Software Architect, OnRelay, Ltd. Prepared exclusively for Robert Walsh Download at WoweBook.Com Hello, Android Introducing Google’s Mobile Development Platform, 2nd Edition Ed Burnette The Pragmatic Bookshelf Raleigh, North Carolina Dallas, Texas Prepared exclusively for Robert Walsh Download at WoweBook.Com Many of the designations used by manufacturers and sellers to distinguish their prod- ucts are claimed as trademarks. Where those designations appear in this book, and The Pragmatic Programmers, LLC was aware of a trademark claim, the designations have been printed in initial capital letters or in all capitals. The Pragmatic Starter Kit, The Pragmatic Programmer, Pragmatic Programming, Pragmatic Bookshelf and the linking g device are trademarks of The Pragmatic Programmers, LLC. Portions of the book’s cover are reproduced from work created and shared by Google and used according to terms described in the Creative Commons 2.5 Attribution License. See http://code.google.com/policies.html#restrictions for details. Every precaution was taken in the preparation of this book. However, the publisher assumes no responsibility for errors or omissions, or for damages that may result from the use of information (including program listings) contained herein. Our Pragmatic courses, workshops, and other products can help you and your team create better software and have more fun. For more information, as well as the latest Pragmatic titles, please visit us at http://www.pragprog.com Copyright © 2009 Ed Burnette. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmit- ted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher. Printed in the United States of America. ISBN-10: 1-934356-49-2 ISBN-13: 978-1-934356-49-4 Printed on acid-free paper. P1.0 printing, October 2009 Version: 2009-10-6 Prepared exclusively for Robert Walsh Download at WoweBook.Com Contents Acknowledgments 9 Preface 10 What Makes Android Special? .................. 10 Who Should Read This Book? ................... 11 What’s in This Book? ........................ 12 What’s New for Cupcake? ..................... 12 What’s New for Donut? ....................... 13 Online Resources .......................... 13 Fast-Forward >> .......................... 14 I Introducing Android 15 1 Quick Start 16 1.1 Installing the Tools ..................... 16 1.2 Creating Your First Program ................ 20 1.3 Running on the Emulator ................. 20 1.4 Running on a Real Phone ................. 23 1.5 Fast-Forward >> ....................... 24 2 Key Concepts 27 2.1 The Big Picture ....................... 27 2.2 It’s Alive! ........................... 32 2.3 Building Blocks ....................... 36 2.4 Using Resources ...................... 37 2.5 Safe and Secure ....................... 38 2.6 Fast-Forward >> ....................... 39 Prepared exclusively for Robert Walsh Download at WoweBook.Com CONTENTS 6 II Android Basics 40 3 Designing the User Interface 41 3.1 Introducing the Sudoku Example ............. 41 3.2 Designing by Declaration ................. 42 3.3 Creating the Opening Screen ............... 43 3.4 Using Alternate Resources ................. 51 3.5 Implementing an About Box ................ 54 3.6 Applying a Theme ...................... 59 3.7 Adding a Menu ....................... 60 3.8 Adding Settings ....................... 63 3.9 Starting a New Game .................... 65 3.10 Debugging with Log Messages ............... 67 3.11 Debugging with the Debugger ............... 68 3.12 Exiting the Game ...................... 68 3.13 Fast-Forward >> ....................... 69 4 Exploring 2D Graphics 70 4.1 Learning the Basics ..................... 70 4.2 Adding Graphics to Sudoku ................ 75 4.3 Handling Input ....................... 84 4.4 The Rest of the Story .................... 90 4.5 Making More Improvements ................ 99 4.6 Fast-Forward >> ....................... 100 5 Multimedia 101 5.1 Playing Audio ........................ 101 5.2 Playing Video ........................ 107 5.3 Adding Sounds to Sudoku ................. 112 5.4 Fast-Forward >> ....................... 115 6 Storing Local Data 116 6.1 Adding Options to Sudoku ................. 116 6.2 Continuing an Old Game ................. 118 6.3 Remembering the Current Position ............ 120 6.4 Accessing the Internal File System ............ 122 6.5 Accessing SD Cards .................... 123 6.6 Fast-Forward >> ....................... 124 Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CONTENTS 7 III Beyond the Basics 125 7 The Connected World 126 7.1 Browsing by Intent ..................... 127 7.2 Web with a View ....................... 131 7.3 From JavaScript to Java and Back ............ 136 7.4 Using Web Services ..................... 143 7.5 Fast-Forward >> ....................... 154 8 Locating and Sensing 155 8.1 Location, Location, Location ................ 155 8.2 Set Sensors to Maximum ................. 161 8.3 Bird’s-Eye View ....................... 164 8.4 Fast-Forward >> ....................... 170 9 Putting SQL to Work 171 9.1 Introducing SQLite ..................... 171 9.2 SQL 101 ........................... 172 9.3 Hello, Database ....................... 174 9.4 Data Binding ......................... 182 9.5 Using a ContentProvider .................. 185 9.6 Implementing a ContentProvider ............. 188 9.7 Fast-Forward >> ....................... 189 10 3D Graphics in OpenGL 191 10.1 Understanding 3D Graphics ................ 191 10.2 Introducing OpenGL .................... 192 10.3 Building an OpenGL Program ............... 193 10.4 Rendering the Scene .................... 195 10.5 Building a Model ...................... 199 10.6 Lights, Camera, ... ..................... 202 10.7 Action! ............................ 205 10.8 Applying Texture ...................... 205 10.9 Peekaboo ........................... 209 10.10 Measuring Smoothness .................. 210 10.11 Fast-Forward >> ....................... 211 Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CONTENTS 8 IV Appendixes 212 A Java vs. the Android Language and APIs 213 A.1 Language Subset ...................... 213 A.2 Standard Library Subset .................. 215 A.3 Third-Party Libraries .................... 216 B Hello, Widget 217 B.1 Creating Your First Widget ................. 217 B.2 Calling All Widgets! ..................... 219 B.3 Stretchto Fit ......................... 220 B.4 The Rest of the Story .................... 221 B.5 Running the Widget ..................... 222 B.6 Keeping Up to Date ..................... 224 B.7 Go Wild ............................ 226 C Publishing to the Android Market 227 C.1 Preparing ........................... 227 C.2 Signing ............................ 230 C.3 Publishing .......................... 231 C.4 Updating ........................... 233 C.5 Closing thoughts ...................... 233 D Bibliography 235 Index 236 Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Acknowledgments I’d like to thank the many people who made this book possible, includ- ing my reviewers Anthony Stevens, Gabor Paller, Fred Burke, Dianne Hackborn, and Laurent Pontier for their attention to detail; Al Sutton for creating an early Donut SDK for developers; my editor Susannah Pfalzer for her great suggestions and good cheer in the face of impossi- ble deadlines; and especially my family for their patience in putting up with all the long hours. Prepared exclusively for Robert Walsh Download at WoweBook.Com Preface Android is a new open source software toolkit for mobile phones that was created by Google and the Open Handset Alliance. In a few years, it’s expected to be found in millions of cell phones and other mobile devices, making Android a major platform for application developers. Whether you’re a hobbyist or a professional programmer, whether you are doing it for fun or for profit, it’s time to learn more about developing for Android. This book will help you get started. What Makes Android Special? There are already many mobile platforms on the market today, includ- ing Symbian, iPhone, Windows Mobile, BlackBerry, Java Mobile Edi- tion, Linux Mobile (LiMo), and more. When I tell people about Android, their first question is often, Why do we need another mobile standard? Where’s the “wow”? Although some of its features have appeared before, Android is the first environment that combines the following: • A truly open, free development platform based on Linux and open source: Handset makers like it because they can use and cus- tomize the platform without paying a royalty. Developers like it because they know that the platform “has legs” and is not locked into any one vendor that may go under or be acquired. • A component-based architecture inspired by Internet mashups: Parts of one application can be used in another in ways not orig- inally envisioned by the developer. You can even replace built-in components with your own improved versions. This will unleash a new round of creativity in the mobile space. • Tons of built-in services out of the box: Location-based services use GPS or cell tower triangulation to let you customize the user expe- rience depending on where you are. A full-powered SQL database Prepared exclusively for Robert Walsh Download at WoweBook.Com WHO SHOULD READ THIS BOOK? 11 lets you harness the power of local storage for occasionally con- nected computing and synchronization. Browser and map views can be embedded directly in your applications. All these built-in capabilities help raise the bar on functionality while lowering your development costs. • Automatic management of the application life cycle: Programs are isolated from each other by multiple layers of security, which will provide a level of system stability not seen before in smart phones. The end user will no longer have to worry about what applications are active or close some programs so that others can run. Android is optimized for low-power, low-memory devices in a fundamental way that no previous platform has attempted. • High-quality graphics and sound: Smooth, antialiased 2D vector graphics and animation inspired by Flash are melded with 3D accelerated OpenGL graphics to enable new kinds of games and business applications. Codecs for the most common industry- standard audio and video formats are built right in, including H.264 (AVC), MP3, and AAC. • Portability across a wide range of current and future hardware: All your programs are written in Java and executed by Android’s Dalvik virtual machine, so your code will be portable across ARM, x86, and other architectures. Support for a variety of input methods is included such as keyboard, touch, and trackball. User interfaces can be customized for any screen resolution and orientation. Android offers a fresh take on the way mobile applications interact with users, along with the technical underpinnings to make it possible. But the best part of Android is the software that you are going to write for it. This book will help you get off to a great start. Who Should Read This Book? The only requirement is a basic understanding of programming in Java or a similar object-oriented language (C# will do in a pinch). You don’t need any prior experience developing software for mobile devices. In fact, if you do, it’s probably best if you try to forget that experience. Android is so different that it’s good to start with an open mind. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com WHAT’SIN THIS BOOK? 12 What’s in This Book? Hello, Android is divided into three parts. Roughly speaking, the book progresses from less advanced to more advanced topics, or from more common to less common aspects of Android. Several chapters share a common example: an Android Sudoku game. By gradually adding features to the game, you’ll learn about many aspects of Android programming including user interfaces, multime- dia, and the Android life cycle. In Part I, we’ll start with an introduction to Android. This is where you’ll learn how to install the Android emulator and how to use an integrated development environment (IDE) to write your first program. Then we’ll introduce a few key concepts like the Android life cycle. Programming in Android is a little different from what you’re probably used to, so make sure you get these concepts before moving on. Part II talks about Android’s user interface, two-dimensional graphics, multimedia components, and simple data access. These features will be used in most programs you write. Part III digs deeper into the Android platform. Here you’ll learn about connecting to the outside world, location-based services, the built-in SQLite database, and three-dimensional graphics. At the end of the book, you’ll find appendices that cover the differences between Android and Java Standard Edition (SE), how to create a wid- get, and publishing your application. What’s New for Cupcake? Android 1.5 (Cupcake) introduced a number of enhancements to the Android platform including support for soft (on-screen) keyboards, video recording, and application widgets. Under the covers, there were more than 1,000 changes to the Android API between 1.1 and 1.5.1 1. http://d.android.com/sdk/api_diff/3/changes.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com WHAT’S NEWFOR DONUT? 13 To accommodate the new version, every page and example in this book has been reviewed and updated so it will work with 1.5. If you’ve read the first edition of this book, then be sure to check out these chapters in particular: • Chapter 1, Q uick Start, on page 16 includes instructions on using target SDKs and Android Virtual Devices (AVDs). • Chapter 8, L ocating and Sensing, on page 155 now uses the new SensorManager APIs and the new setBuiltInZoomControls( ) method. • Chapter 10, 3 D Graphics in OpenGL, on page 191 has been greatly simplified thanks to the new GLSurfaceView class. In addition, by popular demand we’ve added two new appendixes: • Appendix B, on page 217 shows you how to create a Widget for the Home screen. This is a new feature of Cupcake. • Appendix C, on page 227 guides you through the steps of mak- ing your application available for sale or for free on the Android Market. Android 1.5 (or later) is now available for all shipping Android devices. All new devices have it installed, and Google says that almost all older devices have upgraded. This edition of the book does not cover version 1.1 or earlier. What’s New for Donut? Android 1.6 (Donut) added support for high- and low-density displays, plus a number of minor changes that don’t affect most developers.2 It may be a while before all devices are upgraded to 1.6, so Section C.1, Building for 1.5, 1.6, and Beyond, on page 228 covers how to create a single program that supports multiple versions. All the examples in this book have been tested on both 1.5 and 1.6. Online Resources At the website for this book, http://pragprog.com/titles/eband2, you’ll find the following: • The full source code for all the sample programs used in this book 2. http://d.android.com/sdk/api_diff/4/changes.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 14 • An errata page, listing any mistakes in the current edition (let’s hope that will be empty!) • A discussion forum where you can communicate directly with the author and other Android developers (let’s hope that will be full!) You are free to use the source code in your own applications as you see fit. Note: If you’re reading the PDF version of this book, you can also click the little gray rectangle before the code listings to download that source file directly. Fast-Forward >> Although most authors expect you to read every word in their books, I know you’re not going to do that. You want to read just enough to let you get something done, and then maybe you’ll come back later and read something else to let you get another piece done. So, I’ve tried to provide you with a little help so you won’t get lost. Each chapter in this book ends with a “Fast-Forward >>” section. These sections will provide some guidance for where you should go next when you need to read the book out of order. You’ll also find pointers to other resources such as books and online documentation here in case you want to learn more about the subject. So, what are you waiting for? The next chapter—Chapter 1, Q uick Start, on page 16—drops you right into the deep end with your first Android program. Chapter 2, K ey Concepts, on page 27 takes a step back and introduces you to the basic concepts and philosophy of Android, and Chapter 3, D esigning the User Interface, on page 41 digs into the user interface, which will be the most important part of most Android programs. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Part I Introducing Android Prepared exclusively for Robert Walsh Download at WoweBook.Com Chapter 1 Quick Start Android combines the ubiquity of cell phones, the excitement of open source software, and the corporate backing of Google and other Open Handset Alliance members like Intel, TI, T-Mobile, and NTT DoCoMo. The result is a mobile platform you can’t afford not to learn. Luckily, getting started developing with Android is easy. You don’t even need access to an Android phone—just a computer where you can install the Android SDK and phone emulator. In this chapter, I’ll show you how to get all the development tools installed, and then we’ll jump right in and create a working applica- tion: Android’s version of “Hello, World.” 1.1 Installing the Tools The Android software development kit (SDK) works on Windows, Linux, and Mac OS X. The applications you create, of course, can be deployed on any Android devices. Before you start coding, you need to install Java, an IDE, and the Android SDK. Java 5.0+ First you need a copy of Java. All the Android development tools require it, and programs you write will be using the Java language. JDK 5 or 6 is required. It’s not enough to just have a runtime environment (JRE); you need the full development kit. I recommend getting the latest Sun JDK 6.0 Prepared exclusively for Robert Walsh Download at WoweBook.Com INSTALLINGTHE TOOLS 17 update from the Sun download site.1 Mac OS X users should get the latest version of Mac OS X and the JDK from the Apple website. To verify you have the right version, run this command from your shell window. Here’s what I get when I run it: C:\> java -version java version "1.6.0_14" Java(TM) SE Runtime Environment (build 1.6.0_14-b08) Java HotSpot(TM) Client VM (build 14.0-b16, mixed mode, sharing) You should see something similar, with version “1.6.something” or later. Eclipse Next, you should install a Java development environment if you don’t have one already. I recommend Eclipse, because it’s free and because it’s used and supported by the Google developers who created Android. If you don’t want to use Eclipse (there’s always one in every crowd), support for other IDEs such as NetBeans and JetBrains IDEA is avail- able from their respective communities. Or if you’re really old-school, you can forgo an IDE entirely and just use the command-line tools.2 The minimum version of Eclipse is 3.3.1, but you should always use whatever is the most up-to-date production version. Note that you need more than just the standard Eclipse SDK “classic” platform. Go to the Eclipse downloads page,3 and pick “Eclipse IDE for Java Developers.” Follow the directions there for downloading, unpacking, and installing Eclipse into a suitable location (like C:\Eclipse on Windows). Android Next, download the latest Android SDK from Google. The Android down- load page4 has packages for Windows, Mac OS X, and Linux. After downloading the package that’s right for you, unpack the .zip file to a convenient directory (for example, C:\Google). By default, the SDK will be expanded into a subdirectory like android- sdk-windows-1.6_r1. This is your SDK install directory; make a note of the full path so you can refer to it later. 1. http://java.sun.com/javase/downloads 2. S ee http://d.android.com/guide/developing/tools/index.html for documentation on the command-line tools. 3. http://www.eclipse.org/downloads 4. http://d.android.com/sdk Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com INSTALLINGTHE TOOLS 18 Figure 1.1: Installing the Android Development Toolkit No special install program is needed but I do recommend you add the SDK’s bin directory to your PATH. The next step is to start Eclipse and configure it. Eclipse Plug-In To make development easier, Google has written a plug-in for Eclipse called the Android Development Toolkit (ADT). To install the plug-in, follow these steps (note these directions are for Eclipse 3.4—different versions may have slightly different menus and options): 1. Start Eclipse, and select Help > Software Updates.... 2. Click the Available Software tab if it’s not already selected. 3. Click the Add Site... button. 4. Enter the location of the Android update site: https://dl-ssl.google. com/android/eclipse/. If you have trouble with this address, try using http in the location instead of https. Once you’ve filled it out, the dialog box should look like Figure 1.1. Click OK. 5. The Android site should now appear in the Available Software view. Select the checkbox next to it, and then click Install.... If you get an error message, then you may not have the right version of Eclipse. I strongly recommend using either the prebuilt Eclipse IDE for Java or the Eclipse IDE for Java EE Development pack- ages, version 3.4 or newer. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com INSTALLINGTHE TOOLS 19 Joe Asks. . . It Says “Connection Error,” So Now What? If you get a connection error, the most likely cause is some kind of firewall erected by your system administrators. To get outside the firewall, you’ll need to configure Eclipse with the address of your proxy server. This is the same proxy server you use for your web browser, but unfortunately Eclipse isn’t smart enough to pick up the setting from there. To tell Eclipse about the proxy, select Preferences > Network Connections, turn on the option for Manual proxy configura- tion, enter the server name and port number, and click OK. If you don’t see the option, you may be running an older ver- sion of Eclipse. Try looking under Preferences > Install/Update, or search the preferences for the word proxy. If you have a custom install of Eclipse, then to use the Android editors you will also need to install the Web Standard Tools (WST) plug-in and all its prerequisites. See the Web Tools platform home page5 for more details and down- load links. These are already built into the recommended packages mentioned earlier. 6. Click Next, accept the license agreements, and then click Finish to start the download and install process. 7. Once the install is done, restart Eclipse. 8. When Eclipse comes back up, you may see a few error messages because you need to tell it where the Android SDK is located. Select Window > Preferences > Android (Eclipse > Preferences on Mac OS X), and enter the SDK install directory you noted earlier. Click OK. Whew! Luckily, you have to do that only once (or at least once every time a new version of ADT or Eclipse comes out). Now that everything is installed, it’s time to write your first program. 5. http://www.eclipse.org/webtools Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATING YOUR FIRST PROGRAM 20 1.2 Creating Your First Program ADT comes with a built-in example program, or template, that we’re going to use to create a simple “Hello, Android” program in just a few seconds. Get your stopwatch ready. Ready? Set? Go! Select File > New > Project... to open the New Project dialog box. Then select Android > Android Project, and click Next. Enter the following information: Project name: HelloAndroid Build Target: Android 1.6 Application name: Hello, Android Package name: org.example.hello Create Activity: Hello When you’re done, it should look something like Figure 1.2, on the following page. Click Finish. The Android plug-in will create the project and fill it in with some default files. Eclipse will build it and package it up so it will be ready to execute. If you get an error about missing source folders, select Project > Clean to fix it. OK, that takes care of writing the program; now all that’s left is to try running it. First we’ll run it under the Android Emulator. 1.3 Running on the Emulator To run your Android program, go to the Package Explorer window, right-click the HelloAndroid project, and select Run As > Android Appli- cation. If you’re following along in Eclipse you may see an error dialog like the one in Figure 1.3, on page 22. This indicates we haven’t told the Emulator what kind of phone to emulate. Creating an AVD To do this, you need to create an Android Virtual Device (AVD), using either Eclipse or the android avd command.6 It’s easier to use Eclipse, so select Yes in the AVD Error dialog to open the AVD Manager. You can open the manager again later by selecting Window > Android AVD Manager. 6. http://d.android.com/guide/developing/tools/avd.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com RUNNINGONTHE EMULATOR 21 Figure 1.2: New Android project Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com RUNNINGONTHE EMULATOR 22 Keeping Up with the Plug-In The Android Eclipse plug-in is a work in progress that changes much more often than the Android SDK. The version you down- load may be different than the one I used when writing this book, and it may contain a few, shall we say, idiosyncrasies. I recommend you check the plug-in site monthly to pick up any new features and fixes. Figure 1.3: Missing Android Virtual Device (AVD) In the AVD Manager dialog, fill out the fields for the new AVD as follows: Name: em16 Target: Android 1.6 - API Level 4 SDCard: 128M Skin: Default (HVGA) This tells Eclipse to set up a generic device called “em16,” which has the Android 1.6 (Donut) firmware installed. A 128MB virtual Secure Digital (SD) Card will be allocated, along with a half-VGA (320×480) display. When you’re done you should see something like Figure 1.4, on page 24. Due to updates in the plug-in since this was written your screen may look slightly different. Click Create AVD to create the virtual device. A few seconds later you should see a message that the device has been created. Click OK, and then select the AVD and click Start... to bring it up. Close the AVD Manager window when you’re done. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com RUNNINGONA REAL PHONE 23 Donut vs. Cupcake The version of Android running on your emulator (or real phone) must be compatible with your program’s Build Target. For exam- ple, if you try to run an Android 1.6 (Donut) program on an Android 1.5 (Cupcake) phone, it won’t work because Android 1.5 phones can only run 1.5 or earlier programs. Android 1.6 phones, on the other hand, can run programs built for 1.6, 1.5, and earlier. But it may be a while before most phones have been upgraded. So why not just target Android 1.5? Unfortunately applications built for 1.5 don’t always display correctly on the larger and smaller screens found on 1.6 phones. Luckily there’s an easy way to make your programs compatible with both 1.5 and 1.6. See Section C.1, B uilding for 1.5, 1.6, and Beyond, on page 228 for instructions. Let’s Try That Again Once you have a valid AVD, the Android emulator window will start up and boot the Android operating system. The first time you do this, it may take a minute or two, so be patient. You may need to right-click on the project and select Run As > Android Application again. If you see an error message saying that the application is not responding, select the option to continue waiting. Eclipse will send a copy of your program over to the emulator to exe- cute. The application screen comes up, and your “Hello, Android” pro- gram is now running (see Figure 1.5, on page 25). That’s it! Congratu- lations on your first Android program. 1.4 Running on a Real Phone Running an Android program on a physical device such as the T-Mobile G1 during development is almost identical to running it on the emula- tor. All you need to do is connect your phone to the computer with a USB cable and install a special device driver.7 7. You can find the device driver and installation instructions at http://d.android.com/guide/developing/device.html. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 24 Figure 1.4: Creating an AVD in Eclipse Close the emulator window if it’s already open. As long as the phone is plugged in, applications will be loaded and run there instead. When you’re ready to publish your application for others to use, there are a few more steps you’ll need to take. Appendix C, on page 227 will cover that in more detail. 1.5 Fast-Forward >> Thanks to the Eclipse plug-in, creating a skeletal Android program takes only a few seconds. In Chapter 3, D esigning the User Interface, on page 41, we’ll begin to flesh out that skeleton with a real application—a Sudoku game. This sample will be used in several chapters to demon- strate Android’s API. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 25 Figure 1.5: Running the “Hello, Android” program Shortening the Turnaround Starting the emulator is expensive. Think about it this way— when you first turn on your phone, it needs to boot up just like any computer system. Closing the emulator is just like turning off the phone or pulling the batteries out. So, don’t turn it off! Leave the emulator window running as long as Eclipse is run- ning. The next time you start an Android program, Eclipse will notice the emulator is already there and will just send it the new program to run. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 26 But before delving into that, you should take a few minutes to read Chapter 2, K ey Concepts, on the next page. Once you grasp the basic concepts such as activities and life cycles, the rest will be much easier to understand. Although the use of Eclipse to develop Android programs is optional, I highly recommend it. If you’ve never used Eclipse before, you may want to invest in a quick reference such as the Eclipse IDE Pocket Guide [Bur05]. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Chapter 2 Key Concepts Now that you have an idea of what Android is, let’s take a look at how it works. Some parts of Android may be familiar, such as the Linux ker- nel, OpenGL, and the SQL database. Others will be completely foreign, such as Android’s idea of the application life cycle. You’ll need a good understanding of these key concepts in order to write well-behaved Android applications, so if you read only one chapter in this book, read this one. 2.1 The Big Picture Let’s start by taking a look at the overall system architecture—the key layers and components that make up the Android open source software stack. In Figure 2.1, on the following page, you can see the “20,000- foot” view of Android. Study it closely—there will be a test tomorrow. Each layer uses the services provided by the layers below it. Starting from the bottom, the following sections highlight the layers provided by Android. Linux Kernel Android is built on top of a solid and proven foundation: the Linux kernel. Created by Linus Torvalds in 1991 while he was a student at the University of Helsinki, Linux can be found today in everything from wristwatches to supercomputers. Linux provides the hardware abstrac- tion layer for Android, allowing Android to be ported to a wide variety of platforms in the future. Prepared exclusively for Robert Walsh Download at WoweBook.Com THE BIG PICTURE 28 Figure 2.1: Android system architecture Internally, Android uses Linux for its memory management, process management, networking, and other operating system services. The Android phone user will never see Linux and your programs will not make Linux calls directly. As a developer, though, you’ll need to be aware it’s there. Some utilities you need during development interact with Linux. For example, the adb shell command1 will open a Linux shell in which you can enter other commands to run on the device. From there you can examine the Linux file system, view active processes, and so forth, sub- ject to security restrictions. Native Libraries The next layer above the kernel contains the Android native libraries. These shared libraries are all written in C or C++, compiled for the particular hardware architecture used by the phone, and preinstalled by the phone vendor. 1. http://d.android.com/guide/developing/tools/adb.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE BIG PICTURE 29 Some of the most important native libraries include the following: • Surface Manager: Android uses a compositing window manager similar to Vista or Compiz, but it’s much simpler. Instead of draw- ing directly to the screen buffer, your drawing commands go into offscreen bitmaps that are then combined with other bitmaps to form the display the user sees. This lets the system create all sorts of interesting effects such as see-through windows and fancy transitions. • 2D and 3D graphics: Two- and three-dimensional elements can be combined in a single user interface with Android. The library will use 3D hardware if the device has it or a fast software renderer if it doesn’t. See Chapter 4, E xploring 2D Graphics, on page 70 and Chapter 10, 3 D Graphics in OpenGL, on page 191. • Media codecs: Android can play video and record and play back audio in a variety of formats including AAC, AVC (H.264), H.263, MP3, and MPEG-4. See Chapter 5, M ultimedia, on page 101 for an example. • SQL database: Android includes the lightweight SQLite database engine,2 the same database used in Firefox and the Apple iPhone. You can use this for persistent storage in your application. See Chapter 9, P utting SQL to Work, on page 171 for an example. • Browser engine: For the fast display of HTML content, Android uses the WebKit library.3 This is the same engine used in the Google Chrome browser, Apple’s Safari browser, the Apple iPhone, and Nokia’s S60 platform. See Chapter 7, T he Connected World, on page 126 for an example. These libraries are not applications that stand by themselves. They exist only to be called by higher level programs. Starting in Android 1.5, you can write and deploy your own native libraries using the Native Development Toolkit (NDK). Native development is beyond the scope of this book, but if you’re interested you can read all about it online.4 2. http://www.sqlite.org 3. http://www.webkit.org 4. http://d.android.com/sdk/ndk/1.6_r1/index.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE BIG PICTURE 30 Joe Asks. . . What’s a Dalvik? Dalvik is a virtual machine (VM) designed and written by Dan Bornstein at Google. Your code gets compiled into machine- independent instructions called bytecodes, which are then executed by the Dalvik VM on the mobile device. Although the bytecode formats are a little different, Dalvik is essentially a Java virtual machine optimized for low memory requirements. It allows multiple VM instances to run at once and takes advantage of the underlying operating system (Linux) for security and process isolation. Bornstein named Dalvik after a fishing village in Iceland where some of his ancestors lived. Android Runtime Also sitting on top of the kernel is the Android runtime, including the Dalvik virtual machine and the core Java libraries. The Dalvik VM is Google’s implementation of Java, optimized for mobile devices. All the code you write for Android will be written in Java and run within the VM. Dalvik differs from traditional Java in two important ways: • The Dalvik VM runs .dex files, which are converted at compile time from standard .class and .jar files. .dex files are more compact and efficient than class files, an important consideration for the limited memory and battery-powered devices that Android targets. • The core Java libraries that come with Android are different from both the Java Standard Edition (Java SE) libraries and the Java Mobile Edition (Java ME) libraries. There is a substantial amount of overlap, however. In Appendix A, on page 213, you’ll find a com- parison of Android and standard Java libraries. Application Framework Sitting above the native libraries and runtime, you’ll find the Applica- tion Framework layer. This layer provides the high-level building blocks Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE BIG PICTURE 31 you will use to create your applications. The framework comes prein- stalled with Android, but you can also extend it with your own compo- nents as needed. The most important parts of the framework are as follows: • Activity manager: This controls the life cycle of applications (see Section 2.2, I t’s Alive!, on the next page) and maintains a common “backstack” for user navigation. • Content providers: These objects encapsulate data that needs to be shared between applications, such as contacts. See Section 2.3, Content Providers, on page 37. • Resource manager: Resources are anything that goes with your program that is not code. See Section 2.4, U sing Resources, on page 37. • Location manager: An Android phone always knows where it is. See Chapter 8, L ocating and Sensing, on page 155. • Notification manager: Events such as arriving messages, appoint- ments, proximity alerts, alien invasions, and more can be pre- sented in an unobtrusive fashion to the user. Applications and Widgets The highest layer in the Android architecture diagram is the Applica- tions and Widgets layer. Think of this as the tip of the Android iceberg. End users will see only these programs, blissfully unaware of all the action going on below the waterline. As an Android developer, however, you know better. Applications are programs that can take over the whole screen and interact with the user. On the other hand, Widgets (sometimes called gadgets), only operate in a small rectangle of the Home screen applica- tion. The majority of this book will cover application development, because that’s what most of you will be writing. Widget development is covered in Appendix B, on page 217. When someone buys an Android phone, it will come prepackaged with a number of standard system applications, including the following: • Phone dialer • Email Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IT’S ALIVE! 32 Embrace and Extend One of the unique and powerful qualities of Android is that all applications have a level playing field. What I mean is that the system applications have to go through the same public API that you use. You can even tell Android to make your applica- tion replace the standard applications if you want. • Contacts • Web browser • Android Market Using the Android Market, the user will be able to download new pro- grams to run on their phone. That’s where you come in. By the time you finish this book, you’ll be able to write your own killer applications for Android. Now let’s take a closer look at the life cycle of an Android application. It’s a little different from what you’re used to seeing. 2.2 It’s Alive! On your standard Linux or Windows desktop, you can have many appli- cations running and visible at once in different windows. One of the windows has keyboard focus, but otherwise all the programs are equal. You can easily switch between them, but it’s your responsibility as the user to move the windows around so you can see what you’re doing and close programs you don’t need anymore. Android doesn’t work that way. In Android, there is one foreground application, which typically takes over the whole display except for the status line. When the user turns on their phone, the first application they see is the Home application (see Figure 2.2, on the following page). This program typically shows a background image, a search or clock widget, and a scrollable list of other applications the user can invoke. When the user runs an application, Android starts it and brings it to the foreground. From that application, the user might invoke another appli- cation, or another screen in the same application, and then another and Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IT’S ALIVE! 33 Figure 2.2: The Home application another. All these programs and screens are recorded on the applica- tion stack by the system’s Activity Manager. At any time, the user can press the Back button to return to the previous screen on the stack. From the user’s point of view, it works a lot like the history in a web browser. Pressing Back returns them to the previous page. Process != Application Internally, each user interface screen is represented by an Activity class (see Section 2.3, A ctivities, on page 36). Each activity has its own life cycle. An application is one or more activities plus a Linux process to contain them. That sounds pretty straightforward, doesn’t it? But don’t get comfortable yet; I’m about to throw you a curve ball. In Android, an application can be “alive” even if its process has been killed. Put another way, the activity life cycle is not tied to the process life cycle. Processes are just disposable containers for activities. This is Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IT’S ALIVE! 34 Figure 2.3: Life cycle of an Android activity probably different from every other system you’re familiar with, so let’s take a closer look before moving on. Life Cycles of the Rich and Famous During its lifetime, each activity of an Android program can be in one of several states, as shown in Figure 2.3. You, the developer, do not have control over what state your program is in. That’s all managed by the system. However, you do get notified when the state is about to change through the onXX() method calls. You override these methods in your Activity class, and Android will call them at the appropriate time: • onCreate(Bundle): This is called when the activity first starts up. You can use it to perform one-time initialization such as creating the user interface. onCreate( ) takes one parameter that is either Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IT’S ALIVE! 35 null o r some state information previously saved by the onSaveIn- stanceState( ) method. • onStart( ): This indicates the activity is about to be displayed to the user. • onResume( ): This is called when your activity can start interacting with the user. This is a good place to start animations and music. • onPause(): This runs when the activity is about to go into the back- ground, usually because another activity has been launched in front of it. This is where you should save your program’s persis- tent state, such as a database record being edited. • onStop(): This is called when your activity is no longer visible to the user and it won’t be needed for a while. If memory is tight, onStop( ) may never be called (the system may simply terminate your process). • onRestart( ): If this method is called, it indicates your activity is being redisplayed to the user from a stopped state. • onDestroy( ): This is called right before your activity is destroyed. If memory is tight, onDestroy( ) may never be called (the system may simply terminate your process). • onSaveInstanceState(Bundle): Android will call this method to allow the activity to save per-instance state, such as a cursor position within a text field. Usually you won’t need to override it because the default implementation saves the state for all your user inter- face controls automatically. • onRestoreInstanceState(Bundle): This is called when the activity is being reinitialized from a state previously saved by the onSave- InstanceState( ) method. The default implementation restores the state of your user interface. Activities that are not running in the foreground may be stopped or the Linux process that houses them may be killed at any time in order to make room for new activities. This will be a common occurrence, so it’s important that your application be designed from the beginning with this in mind. In some cases, the onPause( ) method may be the last method called in your activity, so that’s where you should save any data you want to keep around for next time. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com BUILDING BLOCKS 36 Flipping the Lid Here’s a quick way to test that your state-saving code is working correctly. In current versions of Android, an orientation change (between portrait and landscape modes) will cause the system to go through the process of saving instance state, pausing, stopping, destroying, and then creating a new instance of the activity with the saved state. On the T-Mobile G1 phone, for example, flipping the lid on the keyboard will trigger this, and on the Android emulator pressing Ctrl+F11 or the 7 or 9 key on the keypad will do it. In addition to managing your program’s life cycle, the Android frame- work provides a number of building blocks that you use to create your applications. Let’s take a look at those next. 2.3 Building Blocks A few objects are defined in the Android SDK that every developer needs to be familiar with. The most important ones are activities, intents, services, and content providers. You’ll see several examples of them in the rest of the book, so I’d like to briefly introduce them now. Activities An a ctivity is a user interface screen. Applications can define one or more activities to handle different phases of the program. As discussed in Section 2.2, I t’s Alive!, on page 32, each activity is responsible for saving its own state so that it can be restored later as part of the application life cycle. See Section 3.3, C reating the Opening Screen, on page 43 for an example. Intents An i ntent is a mechanism for describing a specific action, such as “pick a photo,” “phone home,” or “open the pod bay doors.” In Android, just about everything goes through intents, so you have plenty of opportu- nities to replace or reuse components. See Section 3.5, I mplementing an About Box, on page 54 for an example of an intent. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com USING RESOURCES 37 For example, there is an intent for “send an email.” If your application needs to send mail, you can invoke that intent. Or if you’re writing a new email application, you can register an activity to handle that intent and replace the standard mail program. The next time somebody tries to send an email, they’ll get the option to use your program instead of the standard one. Services A s ervice is a task that runs in the background without the user’s direct interaction, similar to a Unix daemon. For example, consider a music player. The music may be started by an activity, but you want it to keep playing even when the user has moved on to a different program. So, the code that does the actual playing should be in a service. Later, another activity may bind to that service and tell it to switch tracks or stop playing. Android comes with many services built in, along with convenient APIs to access them. Content Providers A c ontent provider is a set of data wrapped up in a custom API to read and write it. This is the best way to share global data between appli- cations. For example, Google provides a content provider for contacts. All the information there—names, addresses, phone numbers, and so forth—can be shared by any application that wants to use it. See Sec- tion 9.5, U sing a ContentProvider, on page 185 for an example. 2.4 Using Resources A resource is a localized text string, bitmap, or other small piece of noncode information that your program needs. At build time all your resources get compiled into your application. You will create and store your resources in the res directory inside your project. The Android resource compiler (aapt)5 processes resources according to which subfolder they are in and the format of the file. For example, PNG and JPG format bitmaps should go in the res/drawable directory, and XML files that describe screen layouts should go in the res/layout directory. 5. http://d.android.com/guide/developing/tools/aapt.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com SAFEAND SECURE 38 The resource compiler compresses and packs your resources and then generates a class named R that contains identifiers you use to reference those resources in your program. This is a little different from standard Java resources, which are referenced by key strings. Doing it this way allows Android to make sure all your references are valid and saves space by not having to store all those resource keys. Eclipse uses a similar method to store and reference the resources in Eclipse plug-ins. We’ll see an example of the code to access a resource in Chapter 3, Designing the User Interface, on page 41. 2.5 Safe and Secure As mentioned earlier, every application runs in its own Linux process. The hardware forbids one process from accessing another process’s memory. Furthermore, every application is assigned a specific user ID. Any files it creates cannot be read or written by other applications. In addition, access to certain critical operations are restricted, and you must specifically ask for permission to use them in a file named Android- Manifest.xml. When the application is installed, the Package Manager either grants or doesn’t grant the permissions based on certificates and, if necessary, user prompts. Here are some of the most common permissions you will need: • INTERNET: Access the Internet. • READ_CONTACTS: Read (but don’t write) the user’s contacts data. • WRITE_CONTACTS: Write (but don’t read) the user’s contacts data. • RECEIVE_SMS: Monitor incoming SMS (text) messages. • ACCESS_COARSE_LOCATION: Use a coarse location provider such as cell towers or wifi. • ACCESS_FINE_LOCATION: Use a more accurate location provider such as GPS. For example, to monitor incoming SMS messages, you would specify this in the manifest file: Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 39 Android can even restrict access to entire parts of the system. Using XML tags in AndroidManifest.xml, you can restrict who can start an activ- ity, start or bind to a service, broadcast intents to a receiver, or access the data in a content provider. This kind of control is beyond the scope of this book, but if you want to learn more, read the online help for the Android security model.6 2.6 Fast-Forward >> The rest of this book will use all the concepts introduced in this chap- ter. In Chapter 3, D esigning the User Interface, on page 41, we’ll use activities and life-cycle methods to define a sample application. Chap- ter 4, E xploring 2D Graphics, on page 70 will use some of the graphics classes in the Android native libraries. Media codecs will be explored in Chapter 5, M ultimedia, on page 101, and content providers will be covered in Chapter 9, P utting SQL to Work, on page 171. 6. http://d.android.com/guide/topics/security/security.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Part II Android Basics Prepared exclusively for Robert Walsh Download at WoweBook.Com Chapter 3 Designing the User Interface In Chapter 1, Q uick Start, on page 16, we used the Android Eclipse plug-in to put together a simple “Hello, Android” program in a few min- utes. In Part II, we’ll create a more substantial example: a Sudoku game. By gradually adding features to the game, you’ll learn about many aspects of Android programming. We’ll start with the user inter- face. You can find all the sample code used in this book at http://pragprog. com/titles/eband2. If you’re reading the PDF version of this book, you can click the little gray rectangle before the code listings to download that file directly. 3.1 Introducing the Sudoku Example Sudoku makes a great sample program for Android because the game itself is so simple. You have a grid of eighty-one tiles (nine across and nine down), and you try to fill them in with numbers so that each col- umn, each row, and each of the three-by-three boxes contains the num- bers 1 through 9 only once. When the game starts, some of the numbers (the givens) are already filled in. All the player has to do is supply the rest. A true Sudoku puzzle has only one unique solution. Sudoku is usually played with pencil and paper, but computerized ver- sions are quite popular too. With the paper version, it’s easy to make a mistake early on, and when that happens, you have to go back and erase most of your work. In the Android version, you can change the tiles as often as you like without having to brush away all those pesky eraser shavings. Prepared exclusively for Robert Walsh Download at WoweBook.Com DESIGNINGBY DECLARATION 42 Sudoku Trivia Most people think Sudoku is some kind of ancient Japanese game, but it’s not. Although similar puzzles can be traced to 19th-century French magazines, most experts credit retired American architect Howard Garns with the invention of mod- ern Sudoku. Number Place, as it was known at the time, was first published in the United States in 1979 by Dell Magazines. Android Sudoku (see Figure 3.1, on the next page) will also offer a few hints to take some of the grunt work out of puzzle solving. At one extreme, it could just solve the puzzle for you, but that wouldn’t be any fun, would it? So, we have to balance the hints against the challenge and not make it too easy. 3.2 Designing by Declaration User interfaces can be designed using one of two methods: procedural and declarative. Procedural simply means in code. For example, when you’re programming a Swing application, you write Java code to cre- ate and manipulate all the user interface objects such as JFrame and JButton. Thus, Swing is procedural. Declarative design, on the other hand, does not involve any code. When you’re designing a simple web page, you use HTML, a markup language based on XML that describes what you want to see on the page, not how you want to do it. HTML is declarative. Android tries to straddle the gap between the procedural and declar- ative worlds by letting you create user interfaces in either style. You can stay almost entirely in Java code, or you can stay almost entirely in XML descriptors. If you look up the documentation for any Android user interface component, you’ll see both the Java APIs and the corre- sponding declarative XML attributes that do the same thing. Which should you use? Either way is valid, but Google’s advice is to use declarative XML as much as possible. The XML code is often shorter and easier to understand than the corresponding Java code, and it’s less likely to change in future versions. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 43 Figure 3.1: The Sudoku example program for Android Now let’s see how we can use this information to create the Sudoku opening screen. 3.3 Creating the Opening Screen We’ll start with a skeleton Android program created by the Eclipse plug- in. Just as you did in Section 1.2, C reating Your First Program, on page 20, create a new “Hello, Android” project, but this time use the following values: Project name: Sudoku Build Target: Android 1.6 Application name: Sudoku Package name: org.example.sudoku Create Activity: Sudoku In a real program, of course, you would use your own names here. The package name is particularly important. Each application in the system Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 44 must have a unique package name. Once you choose a package name, it’s a little tricky to change it because it’s used in so many places. I like to keep the Android emulator window up all the time and run the program after every change, since it takes only a few seconds. If you do that and run the program now, you’ll see a blank screen that just contains the words “Hello World, Sudoku.” The first order of business is to change that into an opening screen for the game, with buttons to let the player start a new game, continue a previous one, get information about the game, or exit. So, what do we have to change to do that? As discussed in Chapter 2, K eyConcepts, on page 27, Android applica- tions are a loose collection of activities, each of which define a user interface screen. When you create the Sudoku project, the Android plug-in makes a single activity for you in Sudoku.java: Download Sudokuv0/src/org/example/sudoku/Sudoku.java package org.example.sudoku; import android.app.Activity; import android.os.Bundle; public class Sudoku extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } } Android calls the onCreate() method of your activity to initialize it. The call to setContentView() fills in the contents of the activity’s screen with an Android view widget. We could have used several lines of Java code, and possibly another class or two, to define the user interface procedurally. But instead, the plug-in chose the declarative route, and we’ll continue along those lines. In the previous code, R.layout.main is a resource identifier that refers to the main.xml file in the res/layout directory (see Figure 3.2, on the following page). main.xml declares the user interface in XML, so that’s the file we need to modify. At runtime, Android parses and instanti- ates (inflates) the resource defined there and sets it as the view for the current activity. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 45 Figure 3.2: Initial resources in the Sudoku project It’s important to note that the R class is managed automatically by the Android Eclipse plug-in. When you put a file anywhere in the res direc- tory, the plug-in notices the change and adds resource IDs in R.java in the gen directory for you. If you remove or change a resource file, R.java is kept in sync. If you bring up the file in the editor, it will look something like this: Download Sudokuv0/gen/org/example/sudoku/R.java /* A UTO-GENERATED FILE. DO NOT MODIFY. * * This class was automatically generated by the * aapt tool from the resource data it found. It * should not be modified by hand. */ package org.example.sudoku; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 46 public final class R{ public static final class attr { } public static final class drawable { public static final int icon=0x7f020000; } public static final class layout { public static final int main=0x7f030000; } public static final class string { public static final int app_name=0x7f040001; public static final int hello=0x7f040000; } } The hex numbers are just integers that the Android resource manager uses to load the real data, the strings, and the other assets that are compiled into your package. You don’t need to worry about their values. Just keep in mind that they are handles that refer to the data, not the objects that contain the data. Those objects won’t be inflated until they are needed. Note that almost every Android program, including the base Android framework itself, has an R class. See the online documentation on android.R for all the built-in resources you can use.1 So, now we know we have to modify main.xml. Let’s dissect the origi- nal definition to see what we have to change. Double-click main.xml in Eclipse to open it. Depending on how you have Eclipse set up, you may see either a visual layout editor or an XML editor. In current versions of ADT, the visual layout editor isn’t that useful, so click main.xml or Source tab at the bottom to see the XML. The first line of main.xml is as follows: All Android XML files start with this line. It just tells the compiler that the file is XML format, in UTF-8 encoding. UTF-8 is almost exactly like regular ASCII text, except it has escape codes for non-ASCII characters such as Japanese glyphs. Next we see a reference to : 1. http://d.android.com/reference/android/R.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 47 Joe Asks. . . Why Does Android Use XML? Isn’t That Inefficient? Android is optimized for mobile devices with limited memory and horsepower, so you may find it strange that it uses XML so pervasively. After all, XML is a verbose, human-readable format not known for its brevity or efficiency, right? Although you see XML when writing your program, the Eclipse plug-in invokes the Android resource compiler, aapt, to prepro- cess the XML into a compressed binary format. It is this format, not the original XML text, that is stored on the device. A layout is a container for one or more child objects and a behavior to position them on the screen within the rectangle of the parent object. Here is a list of the most common layouts provided by Android: • FrameLayout: classArranges its children so they all start at the top left of the screen. This is used for tabbed views and image switchers. • LinearLayout: Arranges its children in a single column or row. This is the most common layout you will use. • RelativeLayout: Arranges its children in relation to each other or to the parent. This is often used in forms. • TableLayout: Arranges its children in rows and columns, similar to an HTML table. Some parameters are common to all layouts: xmlns:android="http://schemas.android.com/apk/res/android" Defines the XML namespace for Android. You should define this once, on the first XML tag in the file. android:layout_width="fill_parent", android:layout_height="fill_parent" Takes up the entire width and height of the parent (in this case, the window). Possible values are fill_parent and wrap_content. Inside the tag you’ll find one child widget: Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 48 This defines a simple text label. Let’s replace that with some different text and a few buttons. Here’s our first attempt: Download Sudokuv1/res/layout/main1.xml If you see warnings in the editor about missing grammar constraints (DTD or XML schema), just ignore them. Instead of hard-coding English text into the layout file, we use the @string/resid syntax to refer to strings in the res/values/strings.xml file. You can have different versions of this and other resource files based on the locale or other parameters such as screen resolution and orientation. Open that file now, switch to the strings.xml tab at the bottom if necessary, and enter this: Download Sudokuv1/res/values/strings.xml Sudoku Android Sudoku Continue New Game About Exit Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 49 Figure 3.3: First version of the opening screen Save strings.xml so Eclipse will rebuild the project. When you run the program now, you should see something like Figure 3.3. It’s readable, but it could use some cosmetic changes. Let’s make the title text larger and centered, make the buttons smaller, and use a different background color. Here’s the color definition, which you should put in res/values/colors.xml: Download Sudokuv1/res/values/colors.xml #3500ffff Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CREATINGTHE OPENING SCREEN 50 And here’s the new layout: Download Sudokuv1/res/layout/main.xml In this version, we introduce a new syntax, @+id/resid. Instead of refer- ring to a resource ID defined somewhere else, this is how you create a new resource ID to which others can refer. For example, @+id/about_ button defines the ID for the About button, which we’ll use later to make something happen when the user presses that button. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com USING ALTERNATE RESOURCES 51 Figure 3.4: Opening screen with new layout The result is shown in Figure 3.4. This new screen looks good in por- trait mode (when the screen is taller than it is wide), but how about landscape mode (wide-screen)? The user can switch modes at any time, for example, by flipping out the keyboard or turning the phone on its side, so you need to handle that. 3.4 Using Alternate Resources As a test, try switching the emulator to landscape mode ( Ctrl+F11 or the 7 or 9 key on the keypad). Oops! The Exit button runs off the bottom of the screen (see Figure 3.5, on page 53). How do we fix that? You could try to adjust the layout so that it works with all orienta- tions. Unfortunately, that’s often not possible or leads to odd-looking screens. When that happens, you’ll need to create a different layout for landscape mode. That’s the approach we’ll take here. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com USING ALTERNATE RESOURCES 52 Joe Asks. . . What Are Dips and Sps? Historically, programmers always designed computer interfaces in terms of pixels. For example, you might make a field 300 pixels wide, allow 5 pixels of spacing between columns, and define icons 16-by-16 pixels in size. The problem is that if you run that program on new displays with more and more dots per inch (dpi), the user interface appears smaller and smaller. At some point, it becomes too hard to read. Resolution-independent measurements help solve this problem. Android supports all the following units: • px (pixels): Dots on the screen. • in (inches): Size as measured by a ruler. • mm (millimeters): Size as measured by a ruler. • pt (points): 1/72 of an inch. • dp (density-independent pixels): An abstract unit based on the density of the screen. On a display with 160 dots per inch, 1dp = 1px. • dip: Synonym for dp, used more often in Google examples. • sp (scale-independent pixels): Similar to dp but also scaled by the user’s font size preference. To make your interface scalable to any current and future type of display, I recommend you always use the sp unit for text sizes and the dip unit for everything else. You should also consider using vector graphics instead of bitmaps (see Chapter 4, E xplor- ing 2D Graphics, on page 70). Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com USING ALTERNATE RESOURCES 53 Figure 3.5: In landscape mode, we can’t see the Exit button. Create a file called res/layout-land/main.xml (note the -land suffix) that contains the following layout: Download Sudokuv1/res/layout-land/main.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IMPLEMENTINGAN ABOUT BOX 54 This uses a TableLayout to create two columns of buttons. Now run the program again (see Figure 3.6, on the next page). Even in landscape mode, all the buttons are visible. You can use resource suffixes to specify alternate versions of any re- sources, not just the layout. For example, you can use them to provide localized text strings in different languages. Each alternate resource file must define exactly the same set of IDs. Android supports suffixes for the current language, region, pixel den- sity, screen size, resolution, input method, and more. See the Android resources documentation for an up-to-date list of suffixes and inheri- tance rules.2 3.5 Implementing an About Box When the user selects the About button, meaning that either they touch it (if they have a touch screen) or they navigate to it with the D-pad (directional pad) or trackball and press the selection button, we want to pop up a window with some information about Sudoku. 2. http://d.android.com/guide/topics/resources/resources-i18n.html#AlternateResources Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IMPLEMENTINGAN ABOUT BOX 55 Figure 3.6: Using a landscape-specific layout lets us see all the buttons. After scrolling through the text, the user can press the Back button to dismiss the window. We can accomplish this in several ways: • Define a new Activity and start it. • Use the AlertDialog class and show it. • Subclass Android’s Dialog class, and show that. For this example, let’s define a new activity. Like the main Sudoku activ- ity, the About activity will need a layout file. We will name it res/layout/ about.xml: Download Sudokuv1/res/layout/about.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IMPLEMENTINGAN ABOUT BOX 56 We need only one version of this layout because it will look fine in both portrait and landscape modes. Now add strings for the title of the About dialog box and the text it contains to res/values/strings.xml: Download Sudokuv1/res/values/strings.xml About Android Sudoku \ Sudoku is a logic-based number placement puzzle. Starting with a partially completed 9x9 grid, the objective is to fill the grid so that each row, each column, and each of the 3x3 boxes (also called blocks) contains the digits 1 to 9 exactly once. Note how a string resource can contain simple HTML formatting and can span multiple lines. In case you’re wondering, the backslash char- acter (\) in about_text prevents an extra blank from appearing before the first word. The About activity should be defined in About.java. All it needs to do is override onCreate( ) and call setContentView( ): Download Sudokuv1/src/org/example/sudoku/About.java package org.example.sudoku; import android.app.Activity; import android.os.Bundle; public class About extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.about); } } Next we need to wire all this up to the About button in the Sudoku class. Start by adding a few imports we’ll need to Sudoku.java: Download Sudokuv1/src/org/example/sudoku/Sudoku.java import android.content.Intent; import android.view.View; import android.view.View.OnClickListener; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IMPLEMENTINGAN ABOUT BOX 57 In the o nCreate( ) method, add code to call findViewById( ) to look up an Android view given its resource ID and setOnClickListener() to tell Android which object to tickle when the user touches or clicks the view: Download Sudokuv1/src/org/example/sudoku/Sudoku.java /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Set up click listeners for all the buttons View continueButton = findViewById(R.id.continue_button); continueButton.setOnClickListener(this); View newButton = findViewById(R.id.new_button); newButton.setOnClickListener(this); View aboutButton = findViewById(R.id.about_button); aboutButton.setOnClickListener(this); View exitButton = findViewById(R.id.exit_button); exitButton.setOnClickListener(this); } While we’re in here, we do the same for all the buttons. Recall that constants like R.id.about_button are created by the Eclipse plug-in in R.java when it sees @+id/about_button in res/layout/main.xml. The code uses this as the receiver, so the Sudoku class needs to imple- ment the OnClickListener interface and define a method called onClick:3 Download Sudokuv1/src/org/example/sudoku/Sudoku.java public class Sudoku extends Activity implements OnClickListener { // ... public void onClick(View v) { switch (v.getId()) { case R.id.about_button: Intent i = new Intent(this, About.class); startActivity(i); break; // More buttons go here (if any) ... } } } To start an activity in Android, we first need to create an instance of the Intent class. There are two kinds of intents: public (named) intents 3. We could have used an anonymous inner class to handle clicks, but according to the Android developers, every new inner class takes up an extra 1KB of memory. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com IMPLEMENTINGAN ABOUT BOX 58 Figure 3.7: Mountain View, we have a problem that are registered with the system and can be called from any appli- cation and private (anonymous) intents that are used within a single application. For this example, we just need the latter kind. If you run the program and select the About button now, you will get an error (see Figure 3.7). What happened? We forgot one important step: every activity needs to be declared in AndroidManifest.xml. To do that, double-click the file to open it, switch to XML mode if necessary by selecting the AndroidManifest.xml tab at the bottom, and add a new tag after the closing tag of the first one: Download Sudokuv1/AndroidManifest.first.xml Now if you save the manifest, run the program again, and select the About button, you should see something like Figure 3.8, on the next page. Press the Back button ( Esc on the emulator) when you’re done. That looks OK, but wouldn’t it be nice if we could see the initial screen behind the About text? Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com APPLYINGA THEME 59 Figure 3.8: First version of the About screen 3.6 Applying a Theme A theme is a collection of styles that override the look and feel of Android widgets. Themes were inspired by Cascading Style Sheets (CSS) used for web pages—they separate the content of a screen and its presen- tation or style. Android is packaged with several themes that you can reference by name,4 or you can make up your own theme by subclass- ing existing ones and overriding their default values. We could define our own custom theme in res/values/styles.xml, but for this example we’ll just take advantage of a predefined one. To use it, open the AndroidManifest.xml editor again, and change the definition of the About activity so it has a theme property. 4. See http://d.android.com/reference/android/R.style.html for symbols beginning with “Theme_.” Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDINGA MENU 60 Figure 3.9: About screen after applying the dialog box theme Download Sudokuv1/AndroidManifest.xml The @ android: prefix in front of the style name means this is a refer- ence to a resource defined by Android, not one that is defined in your program. Running the program again, the About box now looks like Figure 3.9. Many programs need menus and options, so the next two sections will show you how to define them. 3.7 Addinga Menu Android supports two kinds of menus. First, there is the menu you get when you press the physical Menu button. Second, there is a context Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDINGA MENU 61 Joe Asks. . . Why Not Use an HTML View? Android supports embedding a web browser directly into a view through the WebView class (see Section 7.2, W eb with a View, on page 131). So, why didn’t we just use that for the About box? Actually, you could do it either way. A WebView would support far more sophisticated formatting than a simple TextView, but it does have some limitations (such as the inability to use a transparent background). Also, WebView is a heavyweight wid- get that will be slower and take more memory than TextView. For your own applications, use whichever one makes the most sense for your needs. menu that pops up when you press and hold your finger on the screen (or press and hold the trackball or the D-pad center button). Let’s do the first kind so that when the user presses the Menu key, they’ll open a menu like the one in Figure 3.10, on the following page. First we need to define a few strings that we’ll use later: Download Sudokuv1/res/values/strings.xml Settings... Sudoku settings s Music Play background music Hints Show hints during play Then we define the menu using XML in res/menu/menu.xml: Download Sudokuv1/res/menu/menu.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDINGA MENU 62 Figure 3.10: Press the Menu button to open the menu. Next we need to modify the Sudoku class to bring up the menu we just defined. To do that, we’ll need a few more imports: Download Sudokuv1/src/org/example/sudoku/Sudoku.java import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; Then we override the Sudoku.onCreateOptionsMenu( ) method: Download Sudokuv1/src/org/example/sudoku/Sudoku.java @Override public boolean onCreateOptionsMenu(Menu menu) { super.onCreateOptionsMenu(menu); MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menu, menu); return true; } getMenuInflater( ) returns an instance of MenuInflater that we use to read the menu definition from XML and turns it into a real view. When the user selects any menu item, onOptionsItemSelected( ) will be called. Here’s the definition for that method: Download Sudokuv1/src/org/example/sudoku/Sudoku.java @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.settings: startActivity(new Intent(this, Prefs.class)); return true; // More items go here (if any) ... } return false; } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING SETTINGS 63 Prefs i s a class that we’re going to define that displays all our preferences and allows the user to change them. 3.8 Adding Settings Android provides a nice facility for defining what all your program pref- erences are and how to display them using almost no code. You define the preferences in a resource file called res/xml/settings.xml: Download Sudokuv1/res/xml/settings.xml The Sudoku program has two settings: one for background music and one for displaying hints. The keys are constant strings that will be used under the covers in Android’s preferences database. Next define the Prefs class, and make it extend PreferenceActivity: Download Sudokuv1/src/org/example/sudoku/Prefs.java package org.example.sudoku; import android.os.Bundle; import android.preference.PreferenceActivity; public class Prefs extends PreferenceActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.settings); } } The a ddPreferencesFromResource( ) method reads the settings definition from XML and inflates it into views in the current activity. All the heavy lifting takes place in the PreferenceActivity class. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING SETTINGS 64 Figure 3.11: It’s not much to look at, but we got it for free. Don’t forget to register the Prefs activity in AndroidManifest.xml: Download Sudokuv1/AndroidManifest.xml Now rerun Sudoku, press the Menu key, select the Settings... item, and watch with amazement as the Sudoku settings page appears (see Figure 3.11). Try changing the values there and exiting the program, and then come back in and make sure they’re all still set. Code that reads the settings and does something with them will be discussed in a different chapter (Chapter 6, S toring Local Data, on page 116). For now let’s move on to the New Game button. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com STARTINGA NEW GAME 65 3.9 Starting a New Game If you’ve played any Sudoku games, you know that some are easy and some are maddeningly hard. So when the user selects New Game, we want to pop up a dialog box asking them to select between three diffi- culty levels. Selecting from a list of things is easy to do in Android. First we’ll need a few more strings in res/values/strings.xml: Download Sudokuv1/res/values/strings.xml Difficulty Easy Medium Hard Create the list of difficulties as an array resource in res/values/arrays.xml: Download Sudokuv1/res/values/arrays.xml - @string/easy_label
- @string/medium_label
- @string/hard_label
We’ll need a few more imports in the Sudoku class: Download Sudokuv1/src/org/example/sudoku/Sudoku.java import android.app.AlertDialog; import android.content.DialogInterface; import android.util.Log; Add code in the switch statement of the onClick( ) method to handle click- ing the New Game button: Download Sudokuv1/src/org/example/sudoku/Sudoku.java case R.id.new_button: openNewGameDialog(); break; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com STARTINGA NEW GAME 66 Figure 3.12: Difficulty selection dialog box The openNewGameDialog( )method takes care of creating the user inter- face for the difficulty list. Download Sudokuv1/src/org/example/sudoku/Sudoku.java private static final String TAG = "Sudoku"; /** Ask the user what difficulty level they want */ private void openNewGameDialog() { new AlertDialog.Builder(this) .setTitle(R.string.new_game_title) .setItems(R.array.difficulty, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialoginterface, int i) { startGame(i); } }) .show(); } /** Start a new game with the given difficulty level */ private void startGame(int i) { Log.d(TAG, "clicked on " + i); // Start game here... } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com DEBUGGINGWITH LOG MESSAGES 67 The s etItems( ) method takes two parameters: the resource ID of the item list and a listener that will be called when one of the items is selected. When you run the program now and press New Game, you’ll get the dialog box in Figure 3.12, on the previous page. We’re not actually going to start the game yet, so instead when you select a difficulty level, we just print a debug message using the Log.d() method, passing it a tag string and a message to print. 3.10 Debugging with Log Messages The Log class provides several static methods to print messages of var- ious severity levels to the Android system log: • Log.e( ): Errors • Log.w(): Warnings • Log.i( ): Information • Log.d( ): Debugging • Log.v( ): Verbose Users will never see this log, but as a developer you can view it in a couple ways. In Eclipse, open the LogCat view by selecting Window > Show View > Other... > Android > LogCat (see Figure 3.13, on the following page). The view can be filtered by severity or by the tag you specified on the method call. If you’re not using Eclipse, you can see the same output by running the adb logcat command.5 I recommend you start this command in a separate window and leave it running all the time that the emulator is running. It won’t interfere with any other monitors. I can’t stress enough how useful the Android log will be during devel- opment. Remember that error we saw earlier with the About box (Fig- ure 3.7, on page 58)? If you had opened the LogCat view at that point, you would have seen this message: “ActivityNotFoundException: Un- able to find explicit activity class...have you declared this activity in your AndroidManifest.xml?” It doesn’t get any plainer than that. 5. http://d.android.com/guide/developing/tools/adb.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com DEBUGGINGWITHTHE DEBUGGER 68 Figure 3.13: Debugging output in the LogCat view 3.11 Debugging with the Debugger In addition to log messages, you can use the Eclipse debugger to set breakpoints, single step, and view the state of your program. First, en- able your project for debugging by adding the android:debuggable="true" option in your AndroidManifest.xml file:6 Download Sudokuv1/AndroidManifest.xml Then, simply right-click the project, and select Debug As > Android Application. 3.12 Exiting the Game This game doesn’t really need an Exit button, because the user can just press the Back key or the Home key to do something else. But I wanted to add one to show you how to terminate an activity. 6. This is optional if you’re using the emulator but required on a real device. Just remember to remove the option before releasing your code to the public. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 69 Add this to the switch statement in the onClick( ) method: Download Sudokuv1/src/org/example/sudoku/Sudoku.java case R.id.exit_button: finish(); break; When the Exit button is selected, we call the finish( ) method. This shuts down the activity and returns control to the next activity on the Android application stack (usually the Home screen). 3.13 Fast-Forward >> Whew, that was a lot to cover in one chapter! Starting from scratch, you learned how to use layout files to organize your user interface and how to use Android resources for text, colors, and more. You added controls such as buttons and text fields, applied themes to change the program’s appearance, and even added menus and preferences for good measure. Android is a complex system, but you don’t have to know all of it to get started. When you need help, the hundreds of pages of reference material online go into more depth on all the classes and methods used here.7 Another great source for tips and tricks is Planet Android.8 And of course, if you get stuck you can always drop by the discussion forum for this book.9 The other readers and I will be happy to help you out. In Chapter 4, E xploring 2D Graphics, on the following page, we’ll use Android’s graphics API to draw the tiles for the Sudoku game. 7. To view the online documentation, open documentation.html from your Android SDK install location, or point your browser to http://d.android.com/guide/index.html. 8. http://www.planetandroid.com 9. http://forums.pragprog.com/forums/138 Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Chapter 4 Exploring 2D Graphics So far, we’ve covered the basic concepts and philosophy of Android and how to create a simple user interface with a few buttons and a dialog box. You’re really starting to get the hang of this Android thing. But something is missing...what is it? Oh yeah, the fun! Good graphics can add a bit of fun and excitement to any application. Android puts one of the most powerful graphics libraries available on a mobile device at your fingertips. Actually, it puts two of them there: one for two-dimensional graphics and one for three-dimensional graphics.1 In this chapter, we will cover 2D graphics and apply that knowledge to implement the game part of our Sudoku example. Chapter 10, 3D Graphics in OpenGL, on page 191 will cover 3D graphics using the OpenGL ES library. 4.1 Learning the Basics Android provides a complete native two-dimensional graphics library in its android.graphics package. With a basic understanding of classes such as Color and Canvas, you’ll be up and drawing in no time. Color Android colors are represented with four numbers, one each for alpha, red, green, and blue (ARGB). Each component can have 256 possible values, or 8 bits, so a color is typically packed into a 32-bit integer. For 1. Functionality for four-dimensional graphics was considered for Android, but it was dropped because of a lack of time. Prepared exclusively for Robert Walsh Download at WoweBook.Com LEARNINGTHE BASICS 71 efficiency, Android code uses an integer instead of an instance of the Color class. Red, green, and blue are self-explanatory, but alpha might not be. Alpha is a measure of transparency. The lowest value, 0, indicates the color is completely transparent. It doesn’t really matter what the val- ues for RGB are, if A is 0. The highest value, 255, indicates the color is completely opaque. Values in the middle are used for translucent, or semitransparent, colors. They let you see some of what is underneath the object being drawn in the foreground. To create a color, you can use one of the static constants on the Color class, like this: int color = Color.BLUE; // solid blue or if you know the alpha, red, green, and blue numbers, you can use one of the static factory methods such as the following: // Translucent purple color = Color.argb(127, 255, 0, 255); If possible, though, you’re usually better off defining all your colors in an XML resource file. This lets you change them easily in one place later: #7fff00ff You can reference colors by name in other XML files, as we did in Chap- ter 3, or you can use them in Java code like this: color = getResources().getColor(R.color.mycolor); The g etResources( ) method returns the ResourceManager class for the current activity, and getColor( ) asks the manager to look up a color given a resource ID. Paint One of the Android native graphics library’s most important classes is the Paint class. It holds the style, color, and other information needed to draw any graphics including bitmaps, text, and geometric shapes. Normally when you paint something on the screen, you want to draw it in a solid color. You set that color with the Paint.setColor( ) method. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com LEARNINGTHE BASICS 72 For example: cPaint.setColor(Color.LTGRAY); This uses the predefined color value for light gray. Canvas The C anvas class represents a surface on which you draw. Initially can- vases start off devoid of any content, like blank transparencies for an overhead projector. Methods on the Canvas class let you draw lines, rectangles, circles, or other arbitrary graphics on the surface. In Android, the display screen is taken up by an Activity, which hosts a View, which in turn hosts a Canvas. You get an opportunity to draw on that canvas by overriding the View.onDraw( ) method. The only parameter to onDraw( ) is a canvas on which you can draw. Here’s an example activity called Graphics, which contains a view called GraphicsView: public class Graphics extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(new GraphicsView(this)); } static public class GraphicsView extends View { public GraphicsView(Context context) { super(context); } @Override protected void onDraw(Canvas canvas) { // Drawing commands go here } } We’re going to put some drawing commands into the onDraw( ) method in the next section. Path The P ath class holds a set of vector-drawing commands such as lines, rectangles, and curves. Here’s an example that defines a circular path: circle = new Path(); circle.addCircle(150, 150, 100, Direction.CW); Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com LEARNINGTHE BASICS 73 Figure 4.1: Drawing text around a circle This defines a circle at position x=150, y=150, with a radius of 100 pixels. Now that we’ve defined the path, let’s use it to draw the circle’s outline plus some text around the inside: private static final String QUOTE = "Now is the time for all " + "good men to come to the aid of their country."; canvas.drawPath(circle, cPaint); canvas.drawTextOnPath(QUOTE, circle, 0, 20, tPaint); You can see the result in Figure 4.1. Since the circle was drawn in the clockwise direction (Direction.CW), the text is also drawn that way. If you want to get really fancy, Android provides a number of PathEffect classes that let you do things such as apply a random permutation to a path, cause all the line segments along a path to be smoothed out with curves or broken up into segments, and create other effects. Drawable In Android, a Drawable class is used for a visual element like a bitmap or solid color that is intended for display only. You can combine drawables Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com LEARNINGTHE BASICS 74 with other graphics, or you can use them in user interface widgets (for example, as the background for a button or view). Drawables can take a variety of forms: • Bitmap: A PNG or JPEG image. • NinePatch: A stretchable PNG image, so named because originally it divided the image into nine sections. These are used for the background of resizable bitmap buttons. • Shape: Vector-drawing commands, based on Path. This is sort of a poor man’s SVG. • Layers: A container for child drawables that draw on top of each other in a certain z-order. • States: A container that shows one of its child drawables based on its state (a bit mask). One use is to set various selection and focus states for buttons. • Levels: A container that shows only one of its child drawables based on its level (a range of integers). This could be used for a battery or signal strength gauge. • Scale: A container for one child drawable that modifies its size based on the current level. One use might be a zoomable picture viewer. Drawables are almost always defined in XML. Here’s a common exam- ple where a drawable is defined to be a gradient from one color to another (in this case, white to gray). The angle specifies the direction of the gradient (270 degrees means top to bottom). This will be used for the background of a view: To use it, we could either refer to it in XML with the android:background= attribute or call the Canvas.setBackgroundResource( ) method in the view’s onCreate( ) method like this: setBackgroundResource(R.drawable.background); This gives our GraphicsView example a nice gradient background, as shown in Figure 4.2, on the next page. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 75 Figure 4.2: Using a gradient background defined in XML 4.2 Adding Graphics to Sudoku It’s time to apply what we’ve learned to our Sudoku example. When we left it at the end of Chapter 3, the Sudoku game had an opening screen, an About dialog box, and a way to start a new game. But it was missing one very important part: the game! We’ll use the native 2D graphics library to implement that part. Starting the Game First we need to fill in the code that starts the game. startGame( ) takes one parameter, the index of the difficulty name selected from the list. Here’s the new definition: Download Sudokuv2/src/org/example/sudoku/Sudoku.java /** Start a new game with the given difficulty level */ private void startGame(int i) { Log.d(TAG, "clicked on " + i); Intent intent = new Intent(Sudoku.this, Game.class); intent.putExtra(Game.KEY_DIFFICULTY, i); startActivity(intent); } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 76 Sudoku Trivia A few years after it was published in the United States, Num- ber Place was picked up by the Japanese publisher Nikoli, who gave it the much cooler-sounding name Sudoku (which means “single number” in Japanese). From there it was exported around the world, and the rest is history. Sadly, Garns died in 1989 before getting a chance to see his creation become a worldwide sensation. The game part of Sudoku will be another activity called Game, so we create a new intent to kick it off. We place the difficulty number in an extraData area provided in the intent, and then we call the startActivity() method to launch the new activity. The extraData area is a map of key/value pairs that will be passed along to the intent. The keys are strings, and the values can be any prim- itive type, array of primitives, Bundle, or a subclass of Serializable or Parcelable. Defining the Game Class Here’s the outline of the Game activity: Download Sudokuv2/src/org/example/sudoku/Game.java package org.example.sudoku; import android.app.Activity; import android.app.Dialog; import android.os.Bundle; import android.util.Log; import android.view.Gravity; import android.widget.Toast; public class Game extends Activity { private static final String TAG = "Sudoku"; public static final String KEY_DIFFICULTY = "org.example.sudoku.difficulty"; public static final int DIFFICULTY_EASY = 0; public static final int DIFFICULTY_MEDIUM = 1; public static final int DIFFICULTY_HARD = 2; private int puzzle[] = new int[9 * 9]; private PuzzleView puzzleView; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 77 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.d(TAG, "onCreate"); int diff = getIntent().getIntExtra(KEY_DIFFICULTY, DIFFICULTY_EASY); puzzle = getPuzzle(diff); calculateUsedTiles(); puzzleView = new PuzzleView(this); setContentView(puzzleView); puzzleView.requestFocus(); } // ... } The o nCreate() method fetches the difficulty number from the intent and selects a puzzle to play. Then it creates an instance of the PuzzleView class, setting the PuzzleView as the new contents of the view. Since this is a fully customized view, it was easier to do this in code than in XML. The calculateUsedTiles( ) method, which is defined in Section 4.4, T he Rest of the Story, on page 90, uses the rules of Sudoku to figure out, for each tile in the nine-by-nine grid, which numbers are not valid for the tile because they appear elsewhere in the horizontal or vertical direction or in the three-by-three subgrid. This is an activity, so we need to register it in AndroidManifest.xml: Download Sudokuv2/AndroidManifest.xml We also need to add a few more string resources to res/values/strings.xml: Download Sudokuv2/res/values/strings.xml Game No moves Keypad Defining the PuzzleView Class Next we need to define the PuzzleView class. Instead of using an XML layout, this time let’s do it entirely in Java. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 78 What Size Is It Anyway? A common mistake made by new Android developers is to use the width and height of a view inside its constructor. When a view’s constructor is called, Android doesn’t know yet how big the view will be, so the sizes are set to zero. The real sizes are calculated during the layout stage, which occurs after construction but before anything is drawn. You can use the onSizeChanged( ) method to be notified of the values when they are known, or you can use the getWidth( ) and getHeight( ) meth- ods later, such as in the onDraw( ) method. Here’s the outline: Download Sudokuv2/src/org/example/sudoku/PuzzleView.java package org.example.sudoku; import android.content.Context; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.Rect; import android.graphics.Paint.FontMetrics; import android.graphics.Paint.Style; import android.util.Log; import android.view.KeyEvent; import android.view.MotionEvent; import android.view.View; import android.view.animation.AnimationUtils; public class PuzzleView extends View { private static final String TAG = "Sudoku"; private final Game game; public PuzzleView(Context context) { super(context); this.game = (Game) context; setFocusable(true); setFocusableInTouchMode(true); } // ... } In the constructor we keep a reference to the Game class and set the option to allow user input in the view. Inside PuzzleView, we need to implement the onSizeChanged( ) method. This is called after the view is created and Android knows how big everything is. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 79 Other Ways to Do It When I was writing this example, I tried several different ap- proaches such as using a button for each tile or declaring a grid of ImageView classes in XML. After many false starts, I found that the approach of having one view for the entire puzzle and drawing lines and numbers inside that proved to be the fastest and easiest way for this application. It does have its drawbacks, though, such as the need to draw the selection and explicitly handle keyboard and touch events. When designing your own program, I recommend trying stan- dard widgets and views first and then falling back to custom drawing only if that doesn’t work for you. Download Sudokuv2/src/org/example/sudoku/PuzzleView.java private float width; // width of one tile private float height; // height of one tile private int selX; // X index of selection private int selY; // Y index of selection private final Rect selRect = new Rect(); @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { width = w / 9f; height = h / 9f; getRect(selX, selY, selRect); Log.d(TAG, "onSizeChanged: width " + width + ", height " + height); super.onSizeChanged(w, h, oldw, oldh); } private void getRect(int x, int y, Rect rect) { rect.set((int) (x * w idth), (int) (y * h eight), (int) (x * width + width), (int) (y * h eight + height)); } We use o nSizeChanged( ) to calculate the size of each tile on the screen (1/9th of the total view width and height). Note this is a floating-point number, so it’s possible that we could end up with a fractional num- ber of pixels. selRect is a rectangle we’ll use later to keep track of the selection cursor. At this point we’ve created a view for the puzzle, and we know how big it is. The next step is to draw the grid lines that separate the tiles on the board. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 80 Drawing the Board Android calls a view’s onDraw( ) method every time any part of the view needs to be updated. To simplify things, onDraw( ) pretends that you’re re-creating the entire screen from scratch. In reality, you may be draw- ing only a small portion of the view as defined by the canvas’s clip rectangle. Android takes care of doing the clipping for you. Start by defining a few new colors to play with in res/values/colors.xml: Download Sudokuv2/res/values/colors.xml #ffe6f0ff #ffffffff #64c6d4ef #6456648f #ff000000 #64ff0000 #6400ff80 #2000ff80 #64ff8000 Here’s the basic outline for onDraw( ): Download Sudokuv2/src/org/example/sudoku/PuzzleView.java @Override protected void onDraw(Canvas canvas) { // Draw the background... Paint background = new Paint(); background.setColor(getResources().getColor( R.color.puzzle_background)); canvas.drawRect(0, 0, getWidth(), getHeight(), background); // Draw the board... // Draw the numbers... // Draw the hints... // Draw the selection... } The first parameter is the Canvas on which to draw. In this code, we’re just drawing a background for the puzzle using the puzzle_background color. Now let’s add the code to draw the grid lines for the board: Download Sudokuv2/src/org/example/sudoku/PuzzleView.java // Draw the board... // Define colors for the grid lines Paint dark = new Paint(); dark.setColor(getResources().getColor(R.color.puzzle_dark)); Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 81 Paint hilite = new Paint(); hilite.setColor(getResources().getColor(R.color.puzzle_hilite)); Paint light = new Paint(); light.setColor(getResources().getColor(R.color.puzzle_light)); // Draw the minor grid lines for (int i = 0; i < 9; i++) { canvas.drawLine(0, i * height, getWidth(), i * height, light); canvas.drawLine(0, i * height + 1, getWidth(), i * height + 1, hilite); canvas.drawLine(i * width, 0, i * width, getHeight(), light); canvas.drawLine(i * width + 1, 0, i * width + 1, getHeight(), hilite); } // Draw the major grid lines for (int i = 0; i < 9; i++) { if (i % 3 != 0) continue; canvas.drawLine(0, i * height, getWidth(), i * height, dark); canvas.drawLine(0, i * height + 1, getWidth(), i * height + 1, hilite); canvas.drawLine(i * width, 0, i * width, getHeight(), dark); canvas.drawLine(i * width + 1, 0, i * width + 1, getHeight(), hilite); } The code uses three different colors for the grid lines: a light color between each tile, a dark color between the three-by-three blocks, and a highlight color drawn on the edge of each tile to make them look like they have a little depth. The order in which the lines are drawn is important, since lines drawn later will be drawn over the top of earlier lines. You can see what this will look like in Figure 4.3, on the next page. Next, we need some numbers to go inside those lines. Drawing the Numbers The following code draws the puzzle numbers on top of the tiles. The tricky part here is getting each number positioned and sized so it goes in the exact center of its tile. Download Sudokuv2/src/org/example/sudoku/PuzzleView.java // Draw the numbers... // Define color and style for numbers Paint foreground = new Paint(Paint.ANTI_ALIAS_FLAG); Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 82 Figure 4.3: Drawing the grid lines with three colors for effect foreground.setColor(getResources().getColor( R.color.puzzle_foreground)); foreground.setStyle(Style.FILL); foreground.setTextSize(height * 0.75f); foreground.setTextScaleX(width / height); foreground.setTextAlign(Paint.Align.CENTER); // Draw the number in the center of the tile FontMetrics fm = foreground.getFontMetrics(); // Centering in X: use alignment (and X at midpoint) float x = width / 2; // Centering in Y: measure ascent/descent first float y = height / 2 - (fm.ascent + fm.descent) / 2; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { canvas.drawText(this.game.getTileString(i, j), i * width + x, j * height + y, foreground); } } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING GRAPHICSTO SUDOKU 83 Figure 4.4: Centering the numbers inside the tiles We call the getTileString( ) method (defined in Section 4.4, T he Rest of the Story, on page 90) to find out what numbers to display. To calculate the size of the numbers, we set the font height to three-fourths the height of the tile, and we set the aspect ratio to be the same as the tile’s aspect ratio. We can’t use absolute pixel or point sizes because we want the program to work at any resolution. To determine the position of each number, we center it in both the x and y dimensions. The x direction is easy—just divide the tile width by 2. But for the y direction, we have to adjust the starting position downward a little so that the midpoint of the tile will be the midpoint of the number instead of its baseline. We use the graphics library’s FontMetrics class to tell how much vertical space the letter will take in total, and then we divide that in half to get the adjustment. You can see the results in Figure 4.4. That takes care of displaying the puzzle’s starting numbers (the givens). Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com HANDLING INPUT 84 The next step is to allow the player to enter their guesses for all the blank spaces. 4.3 Handling Input One difference in Android programming—as opposed to, say, iPhone programming—is that Android phones come in many shapes and sizes and have a variety of input methods. They might have a keyboard, a D-pad, a touch screen, a trackball, or some combination of these. A good Android program, therefore, needs to be ready to support what- ever input hardware is available, just like it needs to be ready to support any screen resolution. Defining and Updating the Selection First we’re going to implement a little cursor that shows the player which tile is currently selected. The selected tile is the one that will be modified when the player enters a number. This code will draw the selection in onDraw( ): Download Sudokuv2/src/org/example/sudoku/PuzzleView.java // Draw the selection... Log.d(TAG, "selRect=" + selRect); Paint selected = new Paint(); selected.setColor(getResources().getColor( R.color.puzzle_selected)); canvas.drawRect(selRect, selected); We use the selection rectangle calculated earlier in onSizeChanged( ) to draw an alpha-blended color on top of the selected tile. Next we provide a way to move the selection by overriding the onKey- Down( ) method: Download Sudokuv2/src/org/example/sudoku/PuzzleView.java @Override public boolean onKeyDown(int keyCode, KeyEvent event) { Log.d(TAG, "onKeyDown: keycode=" + keyCode + ", event=" + event); switch (keyCode) { case KeyEvent.KEYCODE_DPAD_UP: select(selX, selY - 1); break; case KeyEvent.KEYCODE_DPAD_DOWN: select(selX, selY + 1); break; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com HANDLING INPUT 85 Figure 4.5: Drawing and moving the selection case KeyEvent.KEYCODE_DPAD_LEFT: select(selX - 1, selY); break; case KeyEvent.KEYCODE_DPAD_RIGHT: select(selX + 1, selY); break; default: return super.onKeyDown(keyCode, event); } return true; } If the user has a directional pad (D-pad) and they press the up, down, left, or right button, we call select( ) to move the selection cursor in that direction. How about a trackball? We could override the onTrackballEvent( ) method, but it turns out that if you don’t handle trackball events, Android will translate them into D-pad events automatically. Therefore, we can leave it out for this example. Inside the select( ) method, we calculate the new x and y coordinate of the selection and then use getRect( ) again to calculate the new selection rectangle. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com HANDLING INPUT 86 Download Sudokuv2/src/org/example/sudoku/PuzzleView.java private void select(int x, int y) { invalidate(selRect); selX = Math.min(Math.max(x, 0), 8); selY = Math.min(Math.max(y, 0), 8); getRect(selX, selY, selRect); invalidate(selRect); } Notice the two calls to invalidate(). The first one tells Android that the area covered by the old selection rectangle (on the left of Figure 4.5, on the preceding page) needs to be redrawn. The second invalidate( ) call says that the new selection area (on the right of the figure) needs to be redrawn too. We don’t actually draw anything here. This is an important point: never call any drawing functions except in the onDraw( ) method. Instead, you use the invalidate( ) method to mark rectangles as dirty. The window manager will combine all the dirty rect- angles at some point in the future and call onDraw( ) again for you. The dirty rectangles become the clip region, so screen updates are optimized to only those areas that change. Now let’s provide a way for the player to enter a new number on the selected tile. Entering Numbers To handle keyboard input, we just add a few more cases to the onKey- Down( ) method for the numbers 0 through 9 (0 or space means erase the number). Download Sudokuv2/src/org/example/sudoku/PuzzleView.java case KeyEvent.KEYCODE_0: case KeyEvent.KEYCODE_SPACE: setSelectedTile(0); break; case KeyEvent.KEYCODE_1: setSelectedTile(1); break; case KeyEvent.KEYCODE_2: setSelectedTile(2); break; case KeyEvent.KEYCODE_3: setSelectedTile(3); break; case KeyEvent.KEYCODE_4: setSelectedTile(4); break; case KeyEvent.KEYCODE_5: setSelectedTile(5); break; case KeyEvent.KEYCODE_6: setSelectedTile(6); break; case KeyEvent.KEYCODE_7: setSelectedTile(7); break; case KeyEvent.KEYCODE_8: setSelectedTile(8); break; case KeyEvent.KEYCODE_9: setSelectedTile(9); break; case KeyEvent.KEYCODE_ENTER: case KeyEvent.KEYCODE_DPAD_CENTER: game.showKeypadOrError(selX, selY); break; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com HANDLING INPUT 87 Optimizing Refreshes In an earlier version of this example, I invalidated the entire screen whenever the cursor was moved. Thus, on every key press, the whole puzzle had to be redrawn. This caused it to lag noticeably. Switching the code to invalidate only the smallest rectangles that changed made it run much faster. To support the D-pad, we check for the Enter or center D-pad button in onKeyDown( ) and have it pop up a keypad that lets the user select which number to place. For touch, we override the onTouchEvent( ) method and show the same keypad, which will be defined later: Download Sudokuv2/src/org/example/sudoku/PuzzleView.java @Override public boolean onTouchEvent(MotionEvent event) { if (event.getAction() != MotionEvent.ACTION_DOWN) return super.onTouchEvent(event); select((int) (event.getX() / width), (int) (event.getY() / height)); game.showKeypadOrError(selX, selY); Log.d(TAG, "onTouchEvent: x " + selX + ", y " + selY); return true; } Ultimately, all roads will lead back to a call to setSelectedTile( ) to change the number on a tile: Download Sudokuv2/src/org/example/sudoku/PuzzleView.java public void setSelectedTile(int tile) { if (game.setTileIfValid(selX, selY, tile)) { invalidate();// may change hints } else { // Number is not valid for this tile Log.d(TAG, "setSelectedTile: invalid: " + tile); } } The s howKeypadOrError( ) and setTileIfValid( ) methods will be defined in Section 4.4, T he Rest of the Story, on page 90. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com HANDLING INPUT 88 Note the call to invalidate( ) with no parameters. That marks the whole screen as dirty, which violates my own advice earlier! However, in this case, it’s necessary because any new numbers added or removed might change the hints that we are about to implement in the next section. Adding Hints How can we help the player out a little without solving the whole puzzle for them? How about if we draw the background of each tile differently depending on how many possible moves it has. Add this to onDraw() before drawing the selection: Download Sudokuv2/src/org/example/sudoku/PuzzleView.java // Draw the hints... // Pick a hint color based on #moves left Paint hint = new Paint(); int c[] = { getResources().getColor(R.color.puzzle_hint_0), getResources().getColor(R.color.puzzle_hint_1), getResources().getColor(R.color.puzzle_hint_2), }; Rect r = new Rect(); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { int movesleft = 9 - game.getUsedTiles(i, j).length; if (movesleft < c.length) { getRect(i, j, r); hint.setColor(c[movesleft]); canvas.drawRect(r, hint); } } } We use three states for zero, one, and two possible moves. If there are zero moves, that means the player has done something wrong and needs to backtrack. The result will look like Figure 4.6, on the following page. Can you spot the mistake(s) made by the player?2 Shaking Things Up What if the user tries to enter an obviously invalid number, such as a number that already appears in the three-by-three block? Just for fun, let’s make the screen wiggle back and forth when they do that. First we add a call to the invalid number case in setSelectedTile( ). 2. The two numbers on the bottom row, middle block, are wrong. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com HANDLING INPUT 89 Figure 4.6: Tiles are highlighted based on how many possible values the tile can have. Download Sudokuv2/src/org/example/sudoku/PuzzleView.java // Number is not valid for this tile Log.d(TAG, "setSelectedTile: invalid: " + tile); startAnimation(AnimationUtils.loadAnimation(game, R.anim.shake)); This loads and runs a resource called R.anim.shake, defined in res/anim/ shake.xml, that shakes the screen for 1,000 milliseconds (1 second) by 10 pixels from side to side. Download Sudokuv2/res/anim/shake.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 90 The number of times to run the animation and the velocity and accel- eration of the animation are controlled by an animation interpolator defined in XML. Download Sudokuv2/res/anim/cycle_7.xml This particular one will cause the animation to be repeated seven times. 4.4 The Rest of the Story Now let’s go back and tie up a few loose ends, starting with the Key- pad class. These pieces are necessary for the program to compile and operate but have nothing to do with graphics. Feel free to skip ahead to Section 4.5, M aking More Improvements, on page 99 if you like. Creating the Keypad The keypad is handy for phones that don’t have keyboards. It displays a grid of the numbers 1 through 9 in an activity that appears on top of the puzzle. The whole purpose of the keypad dialog box is to return a number selected by the player. Here’s the user interface layout from res/layout/keypad.xml: Download Sudokuv2/res/layout/keypad.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 91 Next let’s define the Keypad class. Here’s the outline: Download Sudokuv2/src/org/example/sudoku/Keypad.java package org.example.sudoku; import android.app.Dialog; import android.content.Context; import android.os.Bundle; import android.view.KeyEvent; import android.view.View; public class Keypad extends Dialog { protected static final String TAG = "Sudoku"; private final View keys[] = new View[9]; private View keypad; private final int useds[]; private final PuzzleView puzzleView; public Keypad(Context context, int useds[], PuzzleView puzzleView) { super(context); this.useds = useds; this.puzzleView = puzzleView; } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 92 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setTitle(R.string.keypad_title); setContentView(R.layout.keypad); findViews(); for (int element : useds) { if (element != 0) keys[element - 1].setVisibility(View.INVISIBLE); } setListeners(); } // ... } If a particular number is not valid (for example, the same number already appears in that row), then we make the number invisible in the grid so the player can’t select it (see Figure 4.7, on the following page). The findViews( ) method fetches and saves the views for all the keypad keys and the main keypad window: Download Sudokuv2/src/org/example/sudoku/Keypad.java private void findViews() { keypad = findViewById(R.id.keypad); keys[0] = findViewById(R.id.keypad_1); keys[1] = findViewById(R.id.keypad_2); keys[2] = findViewById(R.id.keypad_3); keys[3] = findViewById(R.id.keypad_4); keys[4] = findViewById(R.id.keypad_5); keys[5] = findViewById(R.id.keypad_6); keys[6] = findViewById(R.id.keypad_7); keys[7] = findViewById(R.id.keypad_8); keys[8] = findViewById(R.id.keypad_9); } setListeners( ) loops through all the keypad keys and sets a listener for each one. It also sets a listener for the main keypad window: Download Sudokuv2/src/org/example/sudoku/Keypad.java private void setListeners() { for (int i = 0; i < keys.length; i++) { final int t = i + 1; keys[i].setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { returnResult(t); }}); } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 93 Figure 4.7: Invalid values are hidden in the keypad view. keypad.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { returnResult(0); }}); } When the player selects one of the buttons on the keypad, it calls the returnResult() method with the number for that button. If the player selects a place that doesn’t have a button, then returnResult( ) is called with a zero, indicating the tile should be erased. onKeyDown() is called when the player uses the keyboard to enter a number: Download Sudokuv2/src/org/example/sudoku/Keypad.java @Override public boolean onKeyDown(int keyCode, KeyEvent event) { int tile = 0; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 94 switch (keyCode) { case KeyEvent.KEYCODE_0: case KeyEvent.KEYCODE_SPACE: tile = 0; break; case KeyEvent.KEYCODE_1: tile = 1; break; case KeyEvent.KEYCODE_2: tile = 2; break; case KeyEvent.KEYCODE_3: tile = 3; break; case KeyEvent.KEYCODE_4: tile = 4; break; case KeyEvent.KEYCODE_5: tile = 5; break; case KeyEvent.KEYCODE_6: tile = 6; break; case KeyEvent.KEYCODE_7: tile = 7; break; case KeyEvent.KEYCODE_8: tile = 8; break; case KeyEvent.KEYCODE_9: tile = 9; break; default: return super.onKeyDown(keyCode, event); } if (isValid(tile)) { returnResult(tile); } return true; } If the number is valid for the current tile, then it calls returnResult( ); otherwise, the keystroke is ignored. The isValid( ) method checks to see whether the given number is valid for the current position: Download Sudokuv2/src/org/example/sudoku/Keypad.java private boolean isValid(int tile) { for (int t : useds) { if (tile == t) return false; } return true; } If it appears in the used array, then it’s not valid because the same number is already used in the current row, column, or block. The returnResult( ) method is called to return the number selected to the calling activity: Download Sudokuv2/src/org/example/sudoku/Keypad.java /** Return the chosen tile to the caller */ private void returnResult(int tile) { puzzleView.setSelectedTile(tile); dismiss(); } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 95 We call the PuzzleView.setSelectedTile() method to change the puzzle’s cur- rent tile. The dismiss call terminates the Keypad dialog box. Now that we have the activity, let’s call it in the Game class and retrieve the result: Download Sudokuv2/src/org/example/sudoku/Game.java /** Open the keypad if there are any valid moves */ protected void showKeypadOrError(int x, int y) { int tiles[] = getUsedTiles(x, y); if (tiles.length == 9) { Toast toast = Toast.makeText(this, R.string.no_moves_label, Toast.LENGTH_SHORT); toast.setGravity(Gravity.CENTER, 0, 0); toast.show(); } else { Log.d(TAG, "showKeypad: used=" + toPuzzleString(tiles)); Dialog v = new Keypad(this, tiles, puzzleView); v.show(); } } To decide which numbers are possible, we pass the Keypad a string in the extraData area containing all the numbers that have already been used. Implementing the Game Logic The rest of the code in Game.java concerns itself with the logic of the game, in particular with determining which are and aren’t valid moves according to the rules. The setTileIfValid( ) method is a key part of that. Given an x and y position and the new value of a tile, it changes the tile only if the value provided is valid. Download Sudokuv2/src/org/example/sudoku/Game.java /** Change the tile only if it's a valid move */ protected boolean setTileIfValid(int x, int y, int value) { int tiles[] = getUsedTiles(x, y); if (value != 0) { for (int tile : tiles) { if (tile == value) return false; } } setTile(x, y, value); calculateUsedTiles(); return true; } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 96 To detect valid moves, we create an array for every tile in the grid. For each position, it keeps a list of filled-in tiles that are currently visible from that position. If a number appears on the list, then it won’t be valid for the current tile. The getUsedTiles( ) method retrieves that list for a given tile position: Download Sudokuv2/src/org/example/sudoku/Game.java /** Cache of used tiles */ private final int used[][][] = new int[9][9][]; /** Return cached used tiles visible from the given coords */ protected int[] getUsedTiles(int x, int y) { return used[x][y]; } The array of used tiles is somewhat expensive to compute, so we cache the array and recalculate it only when necessary by calling calculate- UsedTiles( ): Download Sudokuv2/src/org/example/sudoku/Game.java /** Compute the two dimensional array of used tiles */ private void calculateUsedTiles() { for (int x = 0; x < 9; x++) { for (int y = 0; y < 9; y++) { used[x][y] = calculateUsedTiles(x, y); // Log.d(TAG, "used[" + x + "][" + y + "] = " // + toPuzzleString(used[x][y])); } } } calculateUsedTiles( ) simply calls calculateUsedTiles(x, y) on every position in the nine-by-nine grid: Download Sudokuv2/src/org/example/sudoku/Game.java Line 1 /** Compute the used tiles visible from this position */ - private int[] calculateUsedTiles(int x, int y) { - int c[] = new int[9]; - // horizontal 5 for (int i = 0; i < 9; i++) { - if (i == y) - continue; - int t = getTile(x, i); - if (t != 0) 10 c[t - 1] = t; - } - // vertical - for (int i = 0; i < 9; i++) { - if (i == x) 15 continue; Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 97 - int t = getTile(i, y); - if (t != 0) - c[t - 1] = t; - } 20 // same cell block - int startx = (x / 3) * 3; - int starty = (y / 3) * 3; - for (int i = startx; i < startx + 3; i++) { - for (int j = starty; j < starty + 3; j++) { 25 if (i == x && j == y) - continue; - int t = getTile(i, j); - if (t != 0) - c[t - 1] = t; 30 } - } - // compress - int nused = 0; - for (int t : c) { 35 if (t != 0) - nused++; - } - int c1[] = new int[nused]; - nused = 0; 40 for (int t : c) { - if (t != 0) - c1[nused++] = t; - } - return c1; 45 } We start with an array of nine zeros. On line 5, we check all the tiles on the same horizontal row as the current tile, and if a tile is occupied, we stuff its number into the array: On line 13, we do the same thing for all the tiles on the same vertical column, and on line 21, we do the same for tiles in the three-by-three block. The last step, starting at line 33, is to compress the zeros out of the array before we return it. We do this so that array.length can be used to quickly tell how many used tiles are visible from the current position. Miscellaneous Here are a few other utility functions and variables that round out the implementation. easyPuzzle, mediumPuzzle, and hardPuzzle are our hard- coded Sudoku puzzles for easy, medium, and hard difficulty levels, respectively. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com THE RESTOFTHE STORY 98 Download Sudokuv2/src/org/example/sudoku/Game.java private final String easyPuzzle = "360000000004230800000004200" + "070460003820000014500013020" + "001900000007048300000000045"; private final String mediumPuzzle = "650000070000506000014000005" + "007009000002314700000700800" + "500000630000201000030000097"; private final String hardPuzzle = "009000000080605020501078000" + "000000700706040102004000000" + "000720903090301080000000600"; getPuzzle( ) simply takes a difficulty level and returns a puzzle: Download Sudokuv2/src/org/example/sudoku/Game.java /** Given a difficulty level, come up with a new puzzle */ private int[] getPuzzle(int diff) { String puz; // TODO: Continue last game switch (diff) { case DIFFICULTY_HARD: puz = hardPuzzle; break; case DIFFICULTY_MEDIUM: puz = mediumPuzzle; break; case DIFFICULTY_EASY: default: puz = easyPuzzle; break; } return fromPuzzleString(puz); } Later we’ll change getPuzzle() to implement a continue function. toPuzzleString() converts a puzzle from an array of integers to a string. fromPuzzleString( ) does the opposite. Download Sudokuv2/src/org/example/sudoku/Game.java /** Convert an array into a puzzle string */ static private String toPuzzleString(int[] puz) { StringBuilder buf = new StringBuilder(); for (int element : puz) { buf.append(element); } return buf.toString(); } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com MAKING MORE IMPROVEMENTS 99 /** Convert a puzzle string into an array */ static protected int[] fromPuzzleString(String string) { int[] puz = new int[string.length()]; for (int i = 0; i < puz.length; i++) { puz[i] = string.charAt(i) - '0'; } return puz; } The g etTile( ) method takes x and y positions and returns the number currently occupying that tile. If it’s zero, that means the tile is blank. Download Sudokuv2/src/org/example/sudoku/Game.java /** Return the tile at the given coordinates */ private int getTile(int x, int y) { return puzzle[y * 9 + x]; } /** Change the tile at the given coordinates */ private void setTile(int x, int y, int value) { puzzle[y * 9 + x] = value; } getTileString( ) is used when displaying a tile. It will return either a string with the value of the tile or an empty string if the tile is blank. Download Sudokuv2/src/org/example/sudoku/Game.java /** Return a string for the tile at the given coordinates */ protected String getTileString(int x, int y) { int v = getTile(x, y); if (v == 0) return ""; else return String.valueOf(v); } Once all these pieces are in place, you should have a playable Sudoku game. Give it a try to verify it works. As with any code, though, there is room for improvement. 4.5 Making More Improvements Although the code presented in this chapter performs acceptably for a Sudoku game, more complex programs will likely need to be more carefully written in order to squeeze the last drop of performance out of the device. In particular, the onDraw( ) method is a very performance- critical piece of code, so it’s best to do as little as possible there. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 100 Here are some ideas for speeding up this method: • If possible, avoid doing any object allocations in the method onDraw( ). • Prefetch things such as color constants elsewhere (for example, in the view’s constructor). • Create your Paint objects up front, and just use existing instances in onDraw( ). • For values used multiple times, such as the width returned by getWidth(), retrieve the value at the beginning of the method and then access it from your local copy. As a further exercise for the reader, I encourage you to think about how you could make the Sudoku game graphically richer. For example, you could add some fireworks when the player solves the puzzle or make the tiles spin around like Vanna White does. A moving background behind the puzzle might be interesting. Let your imagination go wild. If you want to make a top-notch product, touches like this can add pizzazz to an otherwise ordinary offering. In Chapter 5, M ultimedia, on the next page, we’ll enhance the pro- gram with a little mood music, and in Chapter 6, S toring Local Data, on page 116, we’ll see how to remember the puzzle state and finally implement that Continue button. 4.6 Fast-Forward >> In this chapter, we just scratched the surface of Android’s graphics capabilities. The native 2D library is quite large, so as you’re actually writing your programs, be sure to take advantage of the tooltips, auto- completion, and Javadoc provided by the Android Eclipse plug-in. The online documentation for the android.graphics3 package goes into much more detail if you need it. If your program needs more advanced graphics, you may want to look ahead a bit and read Chapter 10, 3 D Graphics in OpenGL, on page 191. There you’ll find information on how to use Android’s 3D graphics library, which is based on the OpenGL ES standard. Otherwise, turn to the next chapter for an introduction to the wonderful world of Android audio and video. 3. http://d.android.com/reference/android/graphics/package-summary.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Chapter 5 Multimedia Remember those Apple television ads with the silhouette people danc- ing wildly to the beat of their iPods? That’s the kind of excitement you want your products to generate.1 Music, sound effects, and video can make your programs more immersive and engaging than text and graphics alone. This chapter will show you how to add multimedia to your Android application. You may not have your users cavorting in the aisles, but if you do it properly, you can at least put smiles on their faces. 5.1 Playing Audio It was a dark and stormy night.... There goes the starting shot, and they’re off.... The crowd goes wild as State sinks a three-pointer with one second remaining.... Audio cues permeate the environment and set the tempo for our emo- tions. Think of sound as another way to get into your user’s head. Just like you use graphics on the display to convey some information to the user, you can use audio to back that up and reinforce it. Android supports sound and music output through the MediaPlayer class in the android.media package.2 Let’s try it with a simple example that plays sounds when you press a key on the keyboard or D-pad. 1. Of course, normal people older than the age of 8 can’t dance like that. Except perhaps that time when my kids put a lizard in my...but I digress. 2. http://d.android.com/guide/topics/media/index.html Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING AUDIO 102 Figure 5.1: Save sound effects in a compressed format that Android can play. We’ll start by creating a “Hello, Android” project, using the following parameters in the New Android Project dialog box: Project name: Audio Build Target: Android 1.6 Application name: Audio Package name: org.example.audio Create Activity: Audio Next we’ll need a few sounds to play. For this example, I created my own with the Windows Sound Recorder program (Start > Programs > Acces- sories > Entertainment > Sound Recorder on Windows XP) and an inex- pensive headset. After getting the sound levels right, I recorded each sound, selected File > Save As... from the menu, clicked the Change... button, and selected a format Android can recognize (see Figure 5.1). You can find all the sound files and source code for these examples on the book’s website. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING AUDIO 103 Figure 5.2: Copy audio files into the res/raw directory of your project. Copy the sound files into the res/rawdirectory of your project. As you recall from Section 2.4, U sing Resources, on page 37, simply copying a file into the res directory causes the Android Eclipse plug-in to define a Java symbol for you in the R class. When you’re done, the project should look like Figure 5.2. Now it’s time to fill out the Audio activity. First we declare a new Medi- aPlayer instance for each sound and initialize the instances in the onCre- ate( ) method. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING AUDIO 104 Joe Asks. . . What Audio Formats Does Android Support? Well, there’s support on paper, there’s support in the emulator, and there’s support on the actual devices. On paper, Android supports the following file types (this is subject to change with new releases): • WAV (PCM uncompressed) • AAC (Apple iPod format, unprotected) • MP3 (MPEG-3) • WMA (Windows media audio) • AMR (Speech codec) • OGG (Ogg Vorbis)∗ • MIDI (Instruments) In reality, I’ve found that only the OGG, WAV, and MP3 formats work well in the emulator, and thus those are the only ones that I can recommend for application development. Android’s native audio format appears to be 44.1kHz 16-bit stereo. How- ever, since WAV files at that rate are huge, you should just stick to OGG or MP3 files (mono for voice or stereo for music). OGG files seem to work best for short clips like game sound effects. Stay away from unusual rates like 8kHz because the resam- pling artifacts make those rates sound terrible. Use 11kHz, 22kHz, or 44.1kHz sampling rates for the best results. Remember that although the phone may have a tiny speaker, many of your users are going to be plugging in headphones (like an iPod), so you want your audio to be high quality. ∗. http://www.vorbis.com Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING AUDIO 105 Download Audio/src/org/example/audio/Audio.java package org.example.audio; import android.app.Activity; import android.media.MediaPlayer; import android.os.Bundle; import android.view.KeyEvent; public class Audio extends Activity { private MediaPlayer up, down, left, right, enter; private MediaPlayer a, s, d, f; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Native rate is 44.1kHz 16 bit stereo, but // to save space we just use MPEG-3 22kHz mono up = MediaPlayer.create(this, R.raw.up); down = MediaPlayer.create(this, R.raw.down); left = MediaPlayer.create(this, R.raw.left); right = MediaPlayer.create(this, R.raw.right); enter = MediaPlayer.create(this, R.raw.enter); a = MediaPlayer.create(this, R.raw.a); s = MediaPlayer.create(this, R.raw.s); d = MediaPlayer.create(this, R.raw.d); f = MediaPlayer.create(this, R.raw.f); } } There are other ways to do this; for example, you could declare one MediaPlayer and keep reusing it. This would prevent sounds from over- lapping, though, which may or may not be the effect you want. Another method you may be tempted to try is to create a new Medi- aPlayer whenever you want to make a sound. However, this doesn’t work in practice. For one thing, it slows the program down a little. Worse, in my testing it has a tendency to crash after playing just a few sounds. Therefore, I recommend you stick with the tried-and-true method of setting up your players ahead of time and playing them when needed. Now that we have our sounds loaded up and ready to go, we just need to intercept the key presses and play the right sounds. We do that by overriding the Activity.onKeyDown( ) method. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING AUDIO 106 Download Audio/src/org/example/audio/Audio.java Line 1 @Override - public boolean onKeyDown(int keyCode, KeyEvent event) { - MediaPlayer mp; - switch (keyCode) { 5 case KeyEvent.KEYCODE_DPAD_UP: - mp = up; - break; - case KeyEvent.KEYCODE_DPAD_DOWN: - mp = down; 10 break; - case KeyEvent.KEYCODE_DPAD_LEFT: - mp = left; - break; - case KeyEvent.KEYCODE_DPAD_RIGHT: 15 mp = right; - break; - case KeyEvent.KEYCODE_DPAD_CENTER: - case KeyEvent.KEYCODE_ENTER: - mp = enter; 20 break; - case KeyEvent.KEYCODE_A: - mp = a; - break; - case KeyEvent.KEYCODE_S: 25 mp = s; - break; - case KeyEvent.KEYCODE_D: - mp = d; - break; 30 case KeyEvent.KEYCODE_F: - mp = f; - break; - default: - return super.onKeyDown(keyCode, event); 35 } - mp.seekTo(0); - mp.start(); - return true; - } The first part of the method selects a media player based on which key you pressed. Then on line 36, we call the seekTo( ) method to rewind the sound and the start() method to begin playing it. The start( ) method is asynchronous, so it returns immediately regardless of how long the sound lasts. If you like, you can use setOnCompletionListener() to be noti- fied when the clip is finished. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING VIDEO 107 When Things Go Wrong If you do much multimedia programming, you’ll soon discover that Android’s MediaPlayer can be a fickle beast. The version in Android 1.5 is much improved over its predecessors but it can still crash at the slightest provocation. One reason this happens is that MediaPlayer is mostly a native application with a thin layer of Java on top of it. The native player code is optimized for performance, and it doesn’t seem to do much error checking. Fortunately, Android’s strong Linux process protections prevent any harm from being done if a crash occurs. The emulator (or the phone if you’re running on a real device) and other appli- cations will continue to run normally. The user would just see the application go away, possibly with a dialog box containing an error message. During development, though, you can get considerably more diagnostic information to help you determine what went wrong. Messages and tracebacks will be printed to the Android system log, which you can view with the LogCat view in Eclipse or the adb logcat command (see Section 3.10, D ebugging with Log Messages, on page 67). If you run the program now and then press one of the keys (for example, the Enter key or the center D-pad key), you should hear a sound. If you don’t hear anything, check your volume control (don’t laugh), or look at the debugging messages in the LogCat view.3 For our next trick, we’ll play a movie using only one line of code. 5.2 Playing Video Video is more than just a bunch of pictures shown one right after another. It’s sound as well, and the sound has to be closely synchro- nized with the images. 3. Audio output may be choppy or delayed in some cases. Try different formats (such as OGG instead of MP3) and lower bit rates. You may also want to investigate using the SoundPool class, which explicitly supports simultaneous streams. It was buggy and poorly documented in the 1.0 release, but as of 1.5 it appears to be stable. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING VIDEO 108 Joe Asks. . . What Kind of Video Can You Watch on Android? Here’s what is officially supported: • MP4 (MPEG-4 low bit rate) • H.263 (3GP) • H.264 (AVC) As of Android 1.5, H.263 is the recommended video format because every hardware platform supports it and it’s relatively efficient to encode and decode. It is also compatible with other devices such as the iPhone. You can use a program like QuickTime Pro∗ to convert video from one format to another. Use the lowest resolution and bit rate that you can in order to save space, but don’t set it so low that you sacrifice quality. ∗. http://www.apple.com/quicktime/pro Android’s MediaPlayer class works with video the same way it does with plain audio. The only difference is that you need to create a Surface for the player to use to draw the images. You can use the start( ) and stop() methods to control playback. I’m not going to show you another MediaPlayer example, however, be- cause there is a simpler way to embed videos in your application: the VideoView class. To demonstrate it, create a new Android project called Video using these parameters: Project name: Video Build Target: Android 1.6 Application name: Video Package name: org.example.video Create Activity: Video Change the layout (res/layout/main.xml) to this: Download Videov1/res/layout/main.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING VIDEO 109 Open V ideo.java, and change the onCreate( ) method as follows: Download Videov1/src/org/example/video/Video.java package org.example.video; import android.app.Activity; import android.os.Bundle; import android.widget.VideoView; public class Video extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Fill view from resource setContentView(R.layout.main); VideoView video = (VideoView) findViewById(R.id.video); // Load and start the movie video.setVideoPath("/data/samplevideo.3gp"); video.start(); } } The s etVideoPath() method opens the file, sizes it to its container while preserving the aspect ratio, and begins playing it. Now you need to upload something to play. To do that, run the following command: C:\> adb push c:\code\samplevideo.3gp /data/samplevideo.3gp 1649 KB/s (369870 bytes in 0.219s) You can find samplevideo.3gp in the download package for this book, or you can create one of your own. The directory used here (/data) is just for illustrative purposes and should not really be used for media files. It will only work on the emulator because that directory is protected on real devices. Note that Android doesn’t seem to care what extension you give the file. You can also upload and download files in Eclipse with the File Explorer view in the Android perspective, but I find the command line to be easier for simple things like this. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING VIDEO 110 Figure 5.3: Embedding a video is easy with VideoView. There’s one more thing: we’d like the video to take over the whole screen including the title bar and status bar. To do that, all you need to do is specify the right theme in AndroidManifest.xml: Download Videov1/AndroidManifest.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com PLAYING VIDEO 111 Joe Asks. . . Why Does It Restart the Video When I Rotate the Display? Android assumes by default that your program knows nothing about screen rotations. To pick up possible resource changes, Android destroys and re-creates your activity from scratch. That means onCreate( ) is called again, which means the video is started again (as this example is currently written). This behavior will be fine for 90 percent of all applications, so most developers will not have to worry about it. It’s even a useful way to test your application life-cycle and state- saving/restoring code (see Section 2.2, I t’s Alive!, on page 32). However, there are a couple of ways to be smarter and opti- mize the transition. The simplest way is to implement onRetainNonConfigurationIn- stance() in your activity to save some data that will be kept across the calls to onDestroy( ) and onCreate( ). When you come back, you use getLastNonConfigurationInstance( ) in the new instance of your activity to recover that information. You can keep anything, even references to your current intent and running threads. The more complicated way is to use the android:configChanges= property in AndroidManifest.xml to inform Android which changes you can handle. For example, if you set it to keyboardHidden|orientation, then Android will not destroy and re-create your activity when the user flips the keyboard. Instead, it will call onConfigurationChanged(Configuration) and assume you know what you’re doing.∗ ∗. For more details, see http://d.android.com/reference/android/app/Activity.html#ConfigurationChanges. Once all that is done, when you run the program, you should see and hear the movie clip (see Figure 5.3, on the preceding page). Try rotating the display to verify it works in both portrait and landscape modes. Voila! Instant video goodness. Now let’s polish up the Sudoku sample with a little mood music. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING SOUNDSTO SUDOKU 112 Sudoku Trivia Dozens of Sudoku variants exist, although none has gained the popularity of the original. One uses a sixteen-by-sixteen grid, with hexadecimal numbers. Another, called Gattai 5 or Samurai Sudoku, uses five nine-by-nine grids that overlap at the corner regions. 5.3 Adding Sounds to Sudoku In this section, we’re going to take what we’ve learned and add back- ground music to the Sudoku game we’ve been building. One song will play during the opening screen, and another will play during the actual game. This will demonstrate not just how to play music but also some important life-cycle considerations. To add music to the main screen, we just need to override these two methods in the Sudoku class: Download Sudokuv3/src/org/example/sudoku/Sudoku.java @Override protected void onResume() { super.onResume(); Music.play(this, R.raw.main); } @Override protected void onPause() { super.onPause(); Music.stop(this); } If you recall from Section 2.2, I t’s Alive!, on page 32, the o nResume() method is called when the activity is ready to begin interacting with the user. This is a good place to start up the music, so we put a Music.start() call there. The Music class will be defined shortly. R.raw.main refers to res/raw/main.mp3. You can find these sound files in the Sudokuv3 project of the downloadable samples on the book’s website. The onPause( ) method is the paired bookend for onResume( ). Android pauses the current activity prior to resuming a new one, so in Sudoku, Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING SOUNDSTO SUDOKU 113 Joe Asks. . . Shouldn’t We Use a Background Service for Music? We haven’t said much about the Android Service class, but you may have seen it used in some music-playing examples on the Web. Basically, a Service is a way to start a background pro- cess that can run even after your current activity finishes. Ser- vices are similar to, but not quite the same as, Linux daemons. If you’re writing a general-purpose music player and want the music to continue while you’re reading mail or browsing the Web, then, yes, a Service would be appropriate. In most cases, though, you want the music to end when your program ends, so you don’t need to use the Service class. when you start a new game, the Sudoku activity will be paused, and then the Game activity will be started. onPause() will also be called when the user presses the Back or Home key. These are all places where we want our title music to stop, so we call Music.stop( ) in onPause( ). Now let’s do something similar for the music on the Game activity: Download Sudokuv3/src/org/example/sudoku/Game.java @Override protected void onResume() { super.onResume(); Music.play(this, R.raw.game); } @Override protected void onPause() { super.onPause(); Music.stop(this); } If you compare this to what we did to the Sudoku class, you’ll notice that we’re referencing a different sound resource, R.raw.game (res/raw/ game.mp3). Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING SOUNDSTO SUDOKU 114 The final piece of the musical puzzle is the Music class, which will man- age the MediaPlayer class used to play the current music: Download Sudokuv3/src/org/example/sudoku/Music.java Line 1 package org.example.sudoku; - - import android.content.Context; - import android.media.MediaPlayer; 5 - public class Music { - private static MediaPlayer mp = null; - - /** Stop old song and start new one */ 10 public static void play(Context context, int resource) { - stop(context); - mp = MediaPlayer.create(context, resource); - mp.setLooping(true); - mp.start(); 15 } - - /** Stop the music */ - public static void stop(Context context) { - if (mp != null){ 20 mp.stop(); - mp.release(); - mp = null; - } - } 25 } The p lay( ) method first calls the stop( ) method to halt whatever music is currently playing. Next, it creates a new MediaPlayer instance using MediaPlayer.create( ), passing it a context and a resource ID. After we have a player, we then set an option to make it repeat the music in a loop and then start it playing. The start( ) method comes back immediately. The stop() method that begins on line 18 is simple. After a little defen- sive check to make sure we actually have a MediaPlayer to work with, we call its stop( ) and release( ) methods. The MediaPlayer.stop( ) method, strangely enough, stops the music. The release( ) method frees system resources associated with the player. Since those are native resources, we can’t wait until normal Java garbage collection reclaims them. Leav- ing out release( ) is a good way to make your program fail unexpectedly (not that this has ever happened to me, of course; I’m just saying you should keep that in mind). Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 115 Now comes the fun part—try playing Sudoku with these changes in place. Stress test it in every way you can imagine, such as switching to different activities, pressing the Back button and the Home button from different points in the game, starting the program when it’s already running at different points, rotating the display, and so forth. Proper life cycle management is a pain sometimes, but your users will appreciate the effort. 5.4 Fast-Forward >> In this chapter, we covered playing audio and video clips using the Android SDK. We didn’t discuss recording because most programs will not need to do that, but if you happen to be the exception, then look up the MediaRecorder class in the online documentation.4 In Chapter 6, S toring Local Data, on the next page, you’ll learn about some simple ways Android programs can store data between invoca- tions. If you don’t need to do that, then you can skip ahead to Chap- ter 7, T he Connected World, on page 126 and learn about network access. 4. http://d.android.com/reference/android/media/MediaRecorder.html Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Chapter 6 Storing Local Data So far, we’ve concentrated on writing applications that don’t need to keep data around when they exit. They start up, run, and go away, leaving no trace that they were ever there. However, most real programs need persistent state, whether it’s a simple font size setting, an embar- rassing photo from your last office party, or next week’s meal plan. Whatever it is, Android lets you permanently store it on your mobile device for later use and protects it from accidental or malicious access by other programs. Your application can store data using several different techniques de- pending on the size of the data, its structure, its lifetime, and whether it will be shared with other programs. In this chapter, we’ll take a look at three simple methods to keep local data: the preferences API, instance state bundles, and flash memory files. In Chapter 9, P utting SQL to Work, on page 171, we’ll delve into more advanced techniques using the built-in SQLite database engine. 6.1 Adding Options to Sudoku In Section 3.7, A dding a Menu, on page 60, we used the onCreateOption- sMenu() method to add a menu containing one item to the main Sudoku screen. When the user presses the Menu key and selects the Settings... item, the code starts the Prefs activity, which lets the user change the options for the game. Because Prefs extends PreferenceActivity, the values for the settings are stored in the program’s preferences area, but orig- inally we didn’t do anything with them. Now we’re going to implement them. Prepared exclusively for Robert Walsh Download at WoweBook.Com ADDING OPTIONSTO SUDOKU 117 Sudoku Trivia There are 6,670,903,752,021,072,936,960 possible classic Sudoku solution grids. If you eliminate duplicates that are just rotations, reflections, or relabelings of each other, you’re left with “only” 5,472,730,538 solutions. First let’s modify the Prefs class to add a couple of getter methods that retrieve the current values of our two options. Here’s the new definition: Download Sudokuv4/src/org/example/sudoku/Prefs.java package org.example.sudoku; import android.content.Context; import android.os.Bundle; import android.preference.PreferenceActivity; import android.preference.PreferenceManager; public class Prefs extends PreferenceActivity { // Option names and default values private static final String OPT_MUSIC = "music"; private static final boolean OPT_MUSIC_DEF = true; private static final String OPT_HINTS = "hints"; private static final boolean OPT_HINTS_DEF = true; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.settings); } /** Get the current value of the music option */ public static boolean getMusic(Context context) { return PreferenceManager.getDefaultSharedPreferences(context) .getBoolean(OPT_MUSIC, OPT_MUSIC_DEF); } /** Get the current value of the hints option */ public static boolean getHints(Context context) { return PreferenceManager.getDefaultSharedPreferences(context) .getBoolean(OPT_HINTS, OPT_HINTS_DEF); } } Be careful that the option keys (music and hints) match the keys used in res/xml/settings.xml. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CONTINUINGAN OLD GAME 118 Music.play( )has to be modified to check for the music preference: Download Sudokuv4/src/org/example/sudoku/Music.java /** Stop old song and start new one */ public static void play(Context context, int resource) { stop(context); // Start music only if not disabled in preferences if (Prefs.getMusic(context)) { mp = MediaPlayer.create(context, resource); mp.setLooping(true); mp.start(); } } And P uzzleView.onDraw( ) also needs to be modified to check for the hints preference: Download Sudokuv4/src/org/example/sudoku/PuzzleView.java if (Prefs.getHints(getContext())) { // Draw the hints... } If g etHints() returns true, we draw the highlights for the hints, as shown in Figure 4.6, on page 89. Otherwise, we just skip that part. Next I’ll show you how to use the preferences API to store things other than just options. 6.2 Continuing an Old Game At any time the player can decide to quit playing our Sudoku game and go do something else. Maybe their boss walked in, or they got a phone call or a notification of an important appointment. Whatever the reason, we want to allow the player to come back later and continue where they left off. First we need to save the current state of the puzzle somewhere. The preferences API can be used for more than just options; it can store any small stand-alone bits of information that go with your program. In this case, the state of the puzzle can be saved as a string of eighty- one characters, one for each tile. In the Game class, we’ll start by defining a couple of constants—one for the puzzle data key and one for a flag to tell us to continue the previous game rather than start a new one. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com CONTINUINGAN OLD GAME 119 Download Sudokuv4/src/org/example/sudoku/Game.java private static final String PREF_PUZZLE = "puzzle" ; protected static final int DIFFICULTY_CONTINUE = -1; Next we need to save the current puzzle whenever the game is paused. See Section 2.2, I t’s Alive!, on page 32 for a description of onPause( ) and the other life-cycle methods. Download Sudokuv4/src/org/example/sudoku/Game.java @Override protected void onPause() { super.onPause(); Log.d(TAG, "onPause"); Music.stop(this); // Save the current puzzle getPreferences(MODE_PRIVATE).edit().putString(PREF_PUZZLE, toPuzzleString(puzzle)).commit(); } Now the puzzle is saved, but how do we read the saved data? Remember that when the game is started, the getPuzzle( ) method is called, and the difficulty level is passed in. We’ll use that for continuing as well. Download Sudokuv4/src/org/example/sudoku/Game.java /** Given a difficulty level, come up with a new puzzle */ private int[] getPuzzle(int diff) { String puz; switch (diff) { case DIFFICULTY_CONTINUE: puz = getPreferences(MODE_PRIVATE).getString(PREF_PUZZLE, easyPuzzle); break; // ... } return fromPuzzleString(puz); } All we need to do is add a check for DIFFICULTY_CONTINUE. If that is set, then instead of starting with a fresh puzzle, we read the one we stuffed into the preferences. Next, we need to make the Continue button on the main screen (see Figure 3.4, on page 51) actually do something. Here is where we set that up. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com REMEMBERINGTHE CURRENT POSITION 120 Download Sudokuv4/src/org/example/sudoku/Sudoku.java public void onClick(View v) { switch (v.getId()) { case R.id.continue_button: startGame(Game.DIFFICULTY_CONTINUE); break; // ... } } We added a case in Sudoku.onClick( ) to call startGame() when the Con- tinue button is pressed, passing it DIFFICULTY_CONTINUE. startGame() passes the difficulty to the Game activity, and Game.onCreate( ) calls Intent.getIntExtra( ) to read the difficulty and passes that to getPuzzle() (you can see the code for that in Section 4.2, S tarting the Game, on page 75). There’s one more thing to do: restore from our saved game when our activity goes away and comes back on its own (such as if another activ- ity is started and then the user comes back to the Game activity). This modification to the Game.onCreate() method will take care of that: Download Sudokuv4/src/org/example/sudoku/Game.java @Override protected void onCreate(Bundle savedInstanceState) { // ... // If the activity is restarted, do a continue next time getIntent().putExtra(KEY_DIFFICULTY, DIFFICULTY_CONTINUE); } That pretty much covers it for preferences. Next let’s look at saving instance state. 6.3 Remembering the Current Position If you change the screen orientation while Sudoku is running, you’ll notice that it forgets where its cursor is. That’s because we use a cus- tom PuzzleView view. Normal Android views save their view state auto- matically, but since we made our own, we don’t get that for free. Unlike persistent state, instance state is not permanent. It lives in a Bundle class on Android’s application stack. Instance state is intended to be used for small bits of information such as cursor positions. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com REMEMBERINGTHE CURRENT POSITION 121 Here’s what we have to do to implement it: Download Sudokuv4/src/org/example/sudoku/PuzzleView.java Line 1 import android.os.Bundle; - import android.os.Parcelable; - - public class PuzzleView extends View { 5 private static final String SELX = "selX"; - private static final String SELY = "selY"; - private static final String VIEW_STATE = "viewState"; - private static final int ID = 42; - 10 public PuzzleView(Context context) { - // ... - setId(ID); - } - 15 @Override - protected Parcelable onSaveInstanceState() { - Parcelable p = super.onSaveInstanceState(); - Log.d(TAG, "onSaveInstanceState"); - Bundle bundle = new Bundle(); 20 bundle.putInt(SELX, selX); - bundle.putInt(SELY, selY); - bundle.putParcelable(VIEW_STATE, p); - return bundle; - } 25 @Override - protected void onRestoreInstanceState(Parcelable state) { - Log.d(TAG, "onRestoreInstanceState"); - Bundle bundle = (Bundle) state; - select(bundle.getInt(SELX), bundle.getInt(SELY)); 30 super.onRestoreInstanceState(bundle.getParcelable(VIEW_STATE)); - return; - } - // ... - } On line 5, we define some constants for keys to save and restore the cursor position. We need to save both our own x and y positions, plus any state needed by the underlying View class. As part of Activity.onSaveInstanceState( ) processing, Android will walk down the view hierarchy and call View.onSaveInstanceState( ) on every view it finds that has an ID. The same thing happens for onRestoreIn- stanceState( ). Normally, this ID would come from XML, but since Puzzle- View was created in code, we need to set it ourselves. We make up an arbitrary number on line 8 (any value will do as long as it’s positive) and then use the setId() method to assign it on line 12. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ACCESSINGTHE INTERNAL FILE SYSTEM 122 The o nSaveInstanceState( ) method is defined on line 16. We call the superclass to get its state, and then we save ours and theirs in a Bundle. Failing to call the superclass will result in a runtime error. Later, onRestoreInstanceState() (line 26) will be called to tease out the information we saved. We get our own x and y positions from the Bundle, and then we call the superclass to let it get whatever it needs. After making these changes, the cursor will be remembered by PuzzleView, just like any other Android view. Next let’s look at keeping data in plain old files. 6.4 Accessing the Internal File System Android runs Linux under the covers, so there’s a real file system mounted in there with a root directory and everything. The files are stored on nonvolatile flash memory built into the device, so they are not lost when the phone is turned off. All of the usual Java file I/O routines from the java.io package are avail- able for your program to use, with the caveat that your process has limited permissions so it can’t mess up any other application’s data. In fact, the main thing it can access is a package private directory created at install time (/data/data/packagename). A few helper methods are provided on the Context class (and thus on the Activity class extended by each of your activities) to let you read and write data there. Here are the ones you’re most likely to need: deleteFile( ) Delete a private file. Returns true if it worked, false otherwise. fileList() Return a list of all files in the application’s private area in a String array. openFileInput( ) Open a private file for reading. Returns a java.io.FileInputStream. openFileOutput() Open a private file for writing. Returns a java.io.FileOutputStream. However, since this internal memory is limited, I recommend you keep the size of any data you put there low, say a megabyte or two at the most, and carefully handle I/O errors when writing in case the space runs out. Luckily, internal memory isn’t the only storage that you have to work with. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com ACCESSINGSDCARDS 123 All in the Family If you recall from Section 2.5, S afe and Secure, on page 38, each application normally gets its own user ID at install time. That user ID is the only one that is allowed to read and write from the application’s private directory. However, if two applica- tions are signed∗ by the same digital certificate, then Android assumes they are from the same developer and gives them the same user ID. On the one hand, that allows them to share all sorts of data with each other if they so choose. But on the other, it also means they’ll need to take special care to stay out of each other’s way. ∗. http://d.android.com/guide/topics/security/security.html#signing 6.5 Accessing SD Cards Some Android devices will include a slot for additional flash memory to be plugged in, typically a Secure Digital (SD) card. These memory cards, if present, are much larger than the built-in memory, and thus they’re ideal for storing multimegabyte music and video files. They cannot be used for code, and every application can read and write files there. In Section 5.2, P laying Video, on page 107, we uploaded a sample video file to the /data directory of the emulated device. This is the wrong place for it, since we’re not supposed to put large files on the internal file system. So, now I’m going to show you a better way. The first step is to create and format a virtual SD card that we can “plug in” to the emulator. Luckily we’ve already done this—if you recall, in Section 1.3, C reating an AVD, on page 20 when we created the “em15” virtual device, we gave it a 128MB virtual SD card as well. You can make it any size you like, but if you make it too small, it may cause the emulator to crash; if you make it too big, you’ll just waste space on your computer’s disk drive. Next, let’s copy the sample video to the SD card: C:\> adb push c:\code\samplevideo.3gp /sdcard/samplevideo.3gp 1468 KB/s (369870 bytes in 0.246s) Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FAST-FORWARD >> 124 Then we need to modify the onCreate( ) method of the Video class to play the movie from the SD card instead of the /data directory: Download Videov2/src/org/example/video/Video.java // Load and start the movie video.setVideoPath("/sdcard/samplevideo.3gp"); video.start(); Now try to run the program. The video should play normally. Note: Starting with Android 1.6 you will need to request the WRITE_ EXTERNAL_STORAGE permission in your manifest file if you want to write to the SD card from your application. Reading from the card doesn’t require any special permissions. 6.6 Fast-Forward >> In this chapter, we covered a couple of basic ways to store local data on the Android platform. That should be enough to get you started, but for structured data such as phone lists and recipes, you’ll need something more advanced. See Chapter 9, P utting SQL to Work, on page 171 for directions on how to use Android’s built-in SQLite database and how to share information between applications using content providers. This brings us to the end of Part II. With the help of the Sudoku exam- ple, you’ve learned all the basics of Android programming, including user interfaces, 2D graphics, audio, video, and simple data storage. Now it’s time to leave Sudoku behind and move beyond the basics. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com Part III Beyond the Basics Prepared exclusively for Robert Walsh Download at WoweBook.Com Chapter 7 The Connected World Over the next few chapters, we’ll cover more advanced topics such as network access and location-based services. You can write many useful applications without these features, but going beyond the basic fea- tures of Android will really help you add value to your programs, giving them much more functionality with a minimum of effort. What do you use your mobile phone for? Aside from making calls, more and more people are using their phones as mobile Internet devices. Analysts predict that in a few years mobile phones will surpass desktop computers as the number-one way to connect to the Internet.1 This point has already been reached in some parts of the world.2 Android phones are well equipped for the new connected world of the mobile Internet. First, Android provides a full-featured web browser based on the WebKit open source project.3 This is the same engine you will find in Google Chrome, the Apple iPhone, and the Safari desktop browser but with a twist. Android lets you use the browser as a compo- nent right inside your application. Second, Android gives your programs access to standard network ser- vices like TCP/IP sockets. This lets you consume web services from Google, Yahoo, Amazon, and many other sources on the Internet. 1. http://www.idc.com/getdoc.jsp?containerId=prUS21303808 2. http://www.comscore.com/press/release.asp?press=1742 3. http://webkit.org Prepared exclusively for Robert Walsh Download at WoweBook.Com BROWSINGBY INTENT 127 Figure 7.1: Opening a browser using an Android intent In this chapter, you’ll learn how to take advantage of all these features and more through four example programs: • BrowserIntent: Demonstrates opening an external web browser using an Android intent • BrowserView: Shows you how to embed a browser directly into your application • LocalBrowser: Explains how JavaScript in an embedded WebView and Java code in your Android program can talk to each other • Translate: Uses data binding, threading, and web services for an amusing purpose 7.1 Browsing by Intent The simplest thing you can do with Android’s networking API is to open a browser on a web page of your choice. You might want to do this to provide a link to your home page from your program or to access some server-based application such as an ordering system. In Android all it takes is three lines of code. To demonstrate, let’s write a new example called BrowserIntent, which will have an edit field where you can enter a URL and a Go button you press to open the browser on that URL (see Figure 7.1). Start by creating a new “Hello, Android” project with the following values in the New Project wizard: Project name: BrowserIntent Build Target: Android 1.6 Application name: BrowserIntent Package name: org.example.browserintent Create Activity: BrowserIntent Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com BROWSINGBY INTENT 128 Once you have a the basic program, change the layout file (res/layout/ main.xml) so it looks like this: Download BrowserIntent/res/layout/main.xml This defines our two controls, an EditText control and a Button. On EditText, we set android:layout_weight="1.0" to make the text area fill up all the horizontal space to the left of the button, and we also set android:lines="1" to limit the height of the control to one vertical line. Note that this has no effect on the amount of text the user can enter here, just the way it is displayed. Android 1.5 introduced support for soft keyboards and other alternate input methods. The options for android:inputType="textUri" and android:imeOptions="actionGo" are hints for how the soft keyboard should appear. They tell Android to replace the standard keyboard with one that has convenient buttons for “.com” and “/” to enter web addresses and a “Go” button that opens the web page.4 4. See http://d.android.com/reference/android/widget/TextView.html and http://android-developers.blogspot.com/2009/04/updating-applications-for-on-screen.html for more information on input options. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com BROWSINGBY INTENT 129 As always, human-readable text should be put in a resource file, res/ values/strings.xml: Download BrowserIntent/res/values/strings.xml BrowserIntent Go Next we need to fill in the onCreate( ) method in the BrowserIntent class. This is where we’ll build the user interface and hook up all the behavior. If you don’t feel like typing all this in, the complete source code for the examples is available online. Download BrowserIntent/src/org/example/browserintent/BrowserIntent.java Line 1 package org.example.browserintent; - - import android.app.Activity; - import android.content.Intent; 5 import android.net.Uri; - import android.os.Bundle; - import android.view.KeyEvent; - import android.view.View; - import android.view.View.OnClickListener; 10 import android.view.View.OnKeyListener; - import android.widget.Button; - import android.widget.EditText; - - public class BrowserIntent extends Activity { 15 private EditText urlText; - private Button goButton; - - @Override - public void onCreate(Bundle savedInstanceState) { 20 super.onCreate(savedInstanceState); - setContentView(R.layout.main); - - // Get a handle to all user interface elements - urlText = (EditText) findViewById(R.id.url_field); 25 goButton = (Button) findViewById(R.id.go_button); - - // Setup event handlers - goButton.setOnClickListener(new OnClickListener() { - public void onClick(View view) { 30 openBrowser(); - } - }); Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com BROWSINGBY INTENT 130 - urlText.setOnKeyListener(new OnKeyListener() { - public boolean onKey(View view, int keyCode, KeyEvent event) { 35 if (keyCode == KeyEvent.KEYCODE_ENTER) { - openBrowser(); - return true; - } - return false; 40 } - }); - } - } Inside o nCreate( ), we call setContentView() on line 21 to load the view from its definition in the layout resource, and then we call findViewById() on line 24 to get a handle to our two user interface controls. Line 28 tells Android to run some code when the user selects the Go button, either by touching it or by navigating to it and pressing the center D-pad button. When that happens, we call the openBrowser() method, which will be defined in a moment. As a convenience, if the user types an address and hits the Enter key (if their phone has one), we want the browser to open just like they had clicked Go. To do this, we define a listener starting on line 33 that will be called every time the user types a keystroke into the edit field. If it’s the enter key, then we call the openBrowser( ) method to open the browser; otherwise, we return false to let the text control handle the key normally. Now comes the part you’ve been waiting for: the openBrowser( ) method. As promised, it’s three lines long: Download BrowserIntent/src/org/example/browserintent/BrowserIntent.java /** Open a browser on the URL specified in the text box */ private void openBrowser() { Uri uri = Uri.parse(urlText.getText().toString()); Intent intent = new Intent(Intent.ACTION_VIEW, uri); startActivity(intent); } The first line retrieves the address of the web page as a string (for exam- ple, “http://www.android.com”) and converts it to a uniform resource identifier (URI). The next line creates a new Intent class with an action of ACTION_VIEW, passing it the Uri class just created as the object we want to view. Finally, we call the startActivity( ) method to request that this action be performed. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com WEBWITHA VIEW 131 Figure 7.2: Viewing a web page with the default browser When the Browser activity starts, it will create its own view (see Fig- ure 7.2), and your program will be paused. If the user presses the Back key at that point, the browser window will go away, and your appli- cation will continue. But what if you want to see some of your user interface and a web page at the same time? Android allows you to do that by using the WebView class. 7.2 Webwitha View On your desktop computer, a web browser is a large, complicated, memory-gobbling program with all sorts of features like bookmarks, plug-ins, Flash animations, tabs, scroll bars, printing, and so forth. When I was working on the Eclipse project and someone suggested replacing some common text views with embedded web browsers, I thought they were crazy. Wouldn’t it make more sense, I argued, to Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com WEBWITHA VIEW 132 simply enhance the text viewer to do italics or tables or whatever it was that was missing? It turns out they weren’t crazy because: • A web browser can be (relatively) lean and mean if you strip out everything but the basic rendering engine. • If you enhance a text view to add more and more things that a browser engine can do, you end up with either an overly compli- cated, bloated text viewer or an underpowered browser. Android provides a wrapper around the WebKit browser engine called WebView that you can use to get the real power of a browser with as little as 1MB of overhead. Although 1MB is still significant on an embedded device, there are many cases where using a WebView is appropriate. WebView works pretty much like any other Android view except that it has a few extra methods specific to the browser. I’m going to show you how it works by doing an embedded version of the previous example. This one will be called BrowserView instead of BrowserIntent, since it uses an embedded View instead of an Intent. Start by creating a new “Hello, Android” project using these settings: Project name: BrowserView Build Target: Android 1.6 Application name: BrowserView Package name: org.example.browserview Create Activity: BrowserView The layout file for BrowserView is similar to the one in BrowserIntent, except we’ve added a WebView at the bottom: Download BrowserView/res/layout/main.xml We use two LinearLayout controls to make everything appear in the right place. The outermost control divides the screen into top and bottom regions; the top has the text area and button, and the bottom has the WebView. The innermost LinearLayout is the same as before; it just makes the text area go on the left and the button on the right. The onCreate( ) method for BrowserView is exactly the same as before, except that now there is one extra view to look up: Download BrowserView/src/org/example/browserview/BrowserView.java import android.webkit.WebView; // ... public class BrowserView extends Activity { private WebView webView; // ... @Override public void onCreate(Bundle savedInstanceState) { // ... webView = (WebView) findViewById(R.id.web_view); // ... } } The o penBrowser( ) method, however, is different: Download BrowserView/src/org/example/browserview/BrowserView.java /** Open a browser on the URL specified in the text box */ private void openBrowser() { webView.getSettings().setJavaScriptEnabled(true); webView.loadUrl(urlText.getText().toString()); } Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com WEBWITHA VIEW 134 The l oadUrl( ) method causes the browser engine to begin loading and displaying a web page at the given address. It returns immediately even though the actual loading may take some time (if it finishes at all). Don’t forget to update the string resources: Download BrowserView/res/values/strings.xml BrowserView Go We need to make one more change to the program. Add this line to AndroidManifest.xml before the tag: Download BrowserView/AndroidManifest.xml If you leave this out, Android will not give your application access to the Internet, and you’ll get a “Web page not available” error. Try running the program now, and enter a valid web address starting with “http://”; when you press Enter or select the Go button, the web page should appear (see Figure 7.3, on the next page). WebView has dozens of other methods you can use to control what is being displayed or get notifications on state changes. You can find a complete list in the online documentation for WebView, but here are the methods you are most likely to need: • addJavascriptInterface( ): Allows a Java object to be accessed from JavaScript (more on this one in the next section) • createSnapshot( ): Creates a screenshot of the current page • getSettings(): Returns a WebSettings object used to control the settings • loadData(): Loads the given string data into the browser • loadDataWithBaseURL( ): Loads the given data using a base URL • loadUrl(): Loads a web page from the given URL • setDownloadListener( ): Registers callbacks for download events, such as when the user downloads a .zip or .apk file • setWebChromeClient( ): Registers callbacks for events that need to be done outside the WebView rectangle, such as updating the title or progress bar or opening a JavaScript dialog box Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com WEBWITHA VIEW 135 Figure 7.3: Embedding a browser using WebView Joe Asks. . . Why Didn’t BrowserIntent Need ? The previous example, BrowserIntent, simply fired off an intent to request that some other application view the web page. That other application (the browser) is the one that needs to ask for Internet permissions in its own AndroidManifest.xml. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FROM JAVASCRIPTTO JAVA AND BACK 136 • s etWebViewClient( ): Lets the application set hooks in the browser to intercept events such as resource loads, key presses, and autho- rization requests • stopLoading( ): Stops the current page from loading One of the most powerful things you can do with the WebView control is to talk back and forth between it and the Android application that contains it. Let’s take a closer look at this feature now. 7.3 From JavaScript to Java and Back Your Android device can do a number of cool things such as store local data, draw graphics, play music, make calls, and determine its location. Wouldn’t it be nice if you could access that functionality from a web page? With an embedded WebView control, you can. The key is the addJavascriptInterface( ) method in the WebView class. You can use it to extend the Document Object Model (DOM) inside the embedded browser and to define a new object that JavaScript code can access. When the JavaScript code invokes methods on that object, it will actually be invoking methods in your Android program. You can call JavaScript methods from your Android program too. All you have to do is call the loadUrl() method, passing it a URL of the form javascript:code-to-execute. Instead of going to a new page, the browser will execute the given JavaScript expression inside the current page. You can call a method, change JavaScript variables, modify the browser document—anything you need. To demonstrate calls between JavaScript in the WebView and Java in the Android program, let us now build a program that is half HTML/ JavaScript and half Android (see Figure 7.4, on page 138). The top part of the application window is a WebView control, and the bottom part is a TextView and Button from the Android user interface. When you click the buttons and links, it makes calls between the two environments. Start by creating a “Hello, Android” program using these parameters: Project name: LocalBrowser Build Target: Android 1.6 Application name: LocalBrowser Package name: org.example.localbrowser Create Activity: LocalBrowser Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FROM JAVASCRIPTTO JAVA AND BACK 137 Joe Asks. . . Is Allowing JavaScript to Call Java Dangerous? Whenever you allow a web page to access local resources or call functions outside the browser sandbox, you need to con- sider the security implications very carefully. For example, you wouldn’t want to create a method to allow JavaScript to read data from any arbitrary path name because that might expose some private data to a malicious site that knew about your method and your filenames. Here are a few things to keep in mind. First, don’t rely on security by obscurity. Enforce limits on the pages that can use your methods and on the things those methods can do. And remember the golden rule of security: don’t rule things out; rule them in. In other words, don’t try to check for all the bad things that someone can ask you to do (for example, invalid characters in a query). You’re bound to miss something. Instead, disallow everything, and pass only the good things you know are safe. The user interface for this program will be split into two parts. The first part is defined in the Android layout file, res/layout/main.xml: Download LocalBrowser/res/layout/main.xml Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FROM JAVASCRIPTTO JAVA AND BACK 139 The second part is the index.html file that will be loaded into the Web- View. This file goes in the assets directory, not the res directory, because it’s not a compiled resource. Anything in the assets directory is copied verbatim onto local storage when your program is installed. The direc- tory is intended to be used for local copies of HTML, images, and scripts that the browser can view without being connected to the network. Download LocalBrowser/assets/index.html Line 1 - - - - 10 LocalBrowser Call JavaScript from Android The last thing we have to do is wire up the button at the bottom of the screen so it will make a JavaScript call (a call from Java to JavaScript). Download LocalBrowser/src/org/example/localbrowser/LocalBrowser.java // This function will be called when the user presses the // button on the Android side button.setOnClickListener(new OnClickListener() { public void onClick(View view) { Log.d(TAG, "onClick(" + view + ")"); webView.loadUrl("javascript:callJS('Hello from Android')"); } }); To do that, we set a listener for button clicks using setOnClickListener( ). When the button is pressed, onClick( ) is called, which turns around and calls WebView.loadUrl( ), passing it a JavaScript expression to evaluate in Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com USING WEB SERVICES 143 the browser. The expression is a call to the callJS( ) function defined in index.html. Run the program now, and try it. When you click “Display JavaScript alert,” an Android message window will appear. When you click “Call Android from JavaScript,” the string “Hello from Browser” will be dis- played in an Android text control. And finally, when you press the “Call JavaScript from Android” button, the string “Hello from Android” is sent to the browser and inserted in the HTML where it will be displayed at the end of the web page. Sometimes you don’t need to display a web page, but you just need to access some kind of web service or other server-side resource. In the next section, I’ll show you how to do this. 7.4 Using Web Services Android provides a full set of Java-standard networking APIs, such as the java.net.HttpURLConnection package, that you can use in your pro- grams. The tricky part is to make the calls asynchronously so that your program’s user interface will be responsive at all times. Consider what would happen if you just make a blocking network call in your main (GUI) thread. Until that call returns (and it might never return), your application cannot respond to any user interface events such as keystrokes or button presses. It will appear hung to the user. Obviously, that’s something you’ll have to avoid. The java.util.concurrent package is perfect for this kind of work. First cre- ated by Doug Lea as a stand-alone library and later incorporated into Java 5, this package supports concurrent programming at a higher level than the regular Java Thread class. The ExecutorService class man- ages one or more threads for you, and all you have to do is submit tasks (instances of Runnable or Callable) to the executor to have them run. An instance of the Future class is returned, which is a reference to some as-yet-unknown future value that will be returned by your task (if any). You can limit the number of threads that are created, and you can interrupt running tasks if necessary. To illustrate these concepts, let’s create a fun little program that calls the Google Translation API.5 Have you ever laughed at strange trans- lations to and from foreign languages, especially computer-generated 5. http://code.google.com/apis/ajaxlanguage Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com USING WEB SERVICES 144 Figure 7.5: Machine translation is still a work in progress. translations? This program will let the user enter a phrase in one lan- guage, ask Google to translate to a second language, and then ask Google to translate it back into the first language. Ideally, you’d end up with the same words you started with, but this is not always the case, as you can see in Figure 7.5. To use this program, simply select the starting and target languages, and then start typing a phrase. As you type, the program will use the Google Translation web service to translate your text into and out of the target language. To create this application, start with a “Hello, Android” application using these parameters: Project name: Translate Build Target: Android 1.6 Application name: Translate Package name: org.example.translate Create Activity: Translate Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com USING WEB SERVICES 145 Lost in Translation When I first thought of this example, I imagined that it would be easy to get some hilarious results. Unfortunately (or fortunately, depending on your point of view), the Google service does a pretty good job with most languages. If you find any espe- cially funny cases where the translator really flubs up, please post them on the discussion forum at the book’s website (http:// pragprog.com/titles/eband2) for others to enjoy. Since this example will access the Internet to make a web service call, we will need to tell Android to grant us permission. Add this line to AndroidManifest.xml before the XML tag: Download Translate/AndroidManifest.xml The layout for this example is a little more complicated than usual, so we’ll use the TableLayout view. TableLayout lets you arrange your views into rows and columns, taking care of alignment and stretching the columns to fit the content. It’s similar to using and
WebView
-- - Display JavaScript alert -
15- - Call Android from JavaScript -
-20
- - Line 4 of index.html defines the callJS( ) function that our Android pro- gram will be calling later. It takes a string argument and inserts it at the replaceme tag, which is at line 19. In Figure 7.4, on the previous page, you see two HTML links that are defined starting at line 12. The first one just calls a standard win- dow.alert( ) function to open a window displaying a short message. The second link, at line 16, calls the callAndroid( ) method on the window.an- droid object. If you loaded this page into a normal web browser, win- dow.android would be undefined. But since we’re embedding a browser into an Android application, we can define the object ourselves so the page can use it. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FROM JAVASCRIPTTO JAVA AND BACK 140 Next we turn to the Android code in the LocalBrowser class. Here’s the basic outline, including all the imports we’ll need later: Download LocalBrowser/src/org/example/localbrowser/LocalBrowser.java Line 1 package org.example.localbrowser; - - import android.app.Activity; - import android.os.Bundle; 5 import android.os.Handler; - import android.util.Log; - import android.view.View; - import android.view.View.OnClickListener; - import android.webkit.JsResult; 10 import android.webkit.WebChromeClient; - import android.webkit.WebView; - import android.widget.Button; - import android.widget.TextView; - import android.widget.Toast; 15 - public class LocalBrowser extends Activity { - private static final String TAG = "LocalBrowser"; - private final Handler handler = new Handler(); - private WebView webView; 20 private TextView textView; - private Button button; - - @Override - public void onCreate(Bundle savedInstanceState) { 25 super.onCreate(savedInstanceState); - setContentView(R.layout.main); - - // Find the Android controls on the screen - webView = (WebView) findViewById(R.id.web_view); 30 textView = (TextView) findViewById(R.id.text_view); - button = (Button) findViewById(R.id.button); - // Rest of onCreate follows... - } - } Note the initialization of a Handler object at line 18. JavaScript calls come in on a special thread dedicated to the browser, but Android user interface calls can be made only from the main (GUI) thread. We’ll use the Handler class to make the transition. Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FROM JAVASCRIPTTO JAVA AND BACK 141 To call Android Java code from JavaScript, you need to define a plain old Java object with one or more methods, like this: Download LocalBrowser/src/org/example/localbrowser/LocalBrowser.java /** Object exposed to JavaScript */ private class AndroidBridge { public void callAndroid(final String arg) { // must be final handler.post(new Runnable() { public void run() { Log.d(TAG, "callAndroid(" + arg + ")"); textView.setText(arg); } }); } } When JavaScript calls the callAndroid( ) method, the application creates a new Runnable object and post it on the running queue of the main thread using Handler.post( ). As soon as the main thread gets a chance, it will invoke the run() method, which will call setText() to change the text on the TextView object. Now it’s time to tie everything together in the onCreate( ) method. First we turn on JavaScript (it’s off by default) and register our bridge to JavaScript: Download LocalBrowser/src/org/example/localbrowser/LocalBrowser.java // Turn on JavaScript in the embedded browser webView.getSettings().setJavaScriptEnabled(true); // Expose a Java object to JavaScript in the browser webView.addJavascriptInterface(new AndroidBridge(), "android"); Then we create an anonymous WebChromeClient object and register it with the setWebChromeClient( ) method. Download LocalBrowser/src/org/example/localbrowser/LocalBrowser.java // Set up a function to be called when JavaScript tries // to open an alert window webView.setWebChromeClient(new WebChromeClient() { @Override public boolean onJsAlert(final WebView view, final String url, final String message, JsResult result) { Log.d(TAG, "onJsAlert(" + view + ", " + url + ", " + message + ", " + result + ")"); Toast.makeText(LocalBrowser.this, message, 3000).show(); result.confirm(); return true; // I handled it } }); Report erratum this copy is (P1.0 printing, October 2009)Prepared exclusively for Robert Walsh Download at WoweBook.Com FROM JAVASCRIPTTO JAVA AND BACK 142 The term chrome here refers to all the trimmings around a browser window. If this were a full-blown browser client, we’d need to handle navigation, bookmarks, menus, and so forth. In this case, all we want to do is change what happens with JavaScript code when the browser tries to open a JavaScript alert (using window.alert( )). Inside onJsAlert() we use the Android Toast class to create a message window that will appear for a short amount of time (in this case, 3000 milliseconds, or 3 seconds). Once we finish configuring the WebView, we can use loadUrl() to load the local web page: Download LocalBrowser/src/org/example/localbrowser/LocalBrowser.java // Load the web page from a local asset webView.loadUrl("file:///android_asset/index.html"); URLs of the form “file:///android_asset/filename” (note the three for- ward slashes) have a special meaning to Android’s browser engine. As you might have guessed, they refer to files in the assets directory. In this case, we’re loading the index.html file defined earlier. Here is the res/values/strings.xml file for the LocalBrowser example: Download LocalBrowser/res/values/strings.xml