[Android.开发书籍] Android Application Development For Dummies


Donn Felker Independent software development consultant Learn to: • Create apps for hot smartphones like Droid™ X, Galaxy S, and MyTouch® • Download the SDK and get Eclipse up and running • Code Android applications • Submit your apps to the Android Market Android ™ Application Development Making Everything Easier! ™ Visit the companion Web site at www.dummies.com/go/ androidappdevfd for source code, updates, and other examples to help you in the development process Open the book and find: • Cool ways to use the accelerometer in your app • How to turn mobile limitations into opportunities • Tips on installing and setting up the tools • Step-by-step coding directions • Ways to make your apps more marketable • How to create really useful menus • Advice on app pricing • Ten great sample apps and SDKs, including code Donn Felker is an independent consultant specializing in Android and .NET technologies. He has been a technical architect, software developer, and programmer analyst for more than a decade, with experience that covers desktop, Web, and mobile development. $29.99 US / $35.99 CN / £21.99 UK ISBN 978-0-470-77018-4 Programming Languages/Java Go to Dummies.com® for videos, step-by-step examples, how-to articles, or to shop! Here’s just what you need to start developing feature-rich, amazing Android apps Even if you’ve never written a mobile application, this book has the know-how you need to turn your great ideas into cool apps for the Android platform. With millions of smartphone users and a cornucopia of carriers, Android is a great place to ply the app development trade. This book shows you from the ground up how to set up your environment and create an app. Read on to become an Android developer extraordinaire! • Welcome to Android — learn what makes a great Android app, how to use the SDK, ways to work with mobile screens, and how the development process works • Make users happy — find out how to design an interface that mobile users will love • Learn the code — work with the activity lifecycle and Android framework classes, use the Eclipse debugger, and create a home screen widget for your app • Beyond the basics — take your skills up a notch with apps that involve SQLite databases and multiple screens • Price and publish — pick the right price for your app and get it into the Android Market Android ™ Application Development Felker Start with FREE Cheat Sheets Cheat Sheets include • Checklists • Charts • Common Instructions • And Other Good Stuff! Get Smart at Dummies.com Dummies.com makes your life easier with 1,000s of answers on everything from removing wallpaper to using the latest version of Windows. Check out our • Videos • Illustrated Articles • Step-by-Step Instructions Plus, each month you can win valuable prizes by entering our Dummies.com sweepstakes. * Want a weekly dose of Dummies? Sign up for Newsletters on • Digital Photography • Microsoft Windows & Office • Personal Finance & Investing • Health & Wellness • Computing, iPods & Cell Phones • eBay • Internet • Food, Home & Garden Find out “HOW” at Dummies.com *Sweepstakes not currently available in all countries; visit Dummies.com for official rules. Get More and Do More at Dummies.com® To access the Cheat Sheet created specifically for this book, go to www.dummies.com/cheatsheet/androidapplicationdevelopment Mobile Apps There’s a Dummies App for This and That With more than 200 million books in print and over 1,600 unique titles, Dummies is a global leader in how-to information. Now you can get the same great Dummies information in an App. With topics such as Wine, Spanish, Digital Photography, Certification, and more, you’ll have instant access to the topics you need to know in a format you can trust. To get information on all our Dummies apps, visit the following: www.Dummies.com/go/mobile from your computer. www.Dummies.com/go/iphone/apps from your phone. Android ™ Application Development FOR DUMmIES‰ 01_9780470770184-ffirs.indd i01_9780470770184-ffirs.indd i 11/2/10 8:45 AM11/2/10 8:45 AM 01_9780470770184-ffirs.indd ii01_9780470770184-ffirs.indd ii 11/2/10 8:45 AM11/2/10 8:45 AM by Donn Felker with Joshua Dobbs Android ™ Application Development FOR DUMmIES‰ 01_9780470770184-ffirs.indd iii01_9780470770184-ffirs.indd iii 11/2/10 8:45 AM11/2/10 8:45 AM AndroidTM Application Development For Dummies® Published by Wiley Publishing, Inc. 111 River Street Hoboken, NJ 07030-5774 www.wiley.com Copyright © 2011 by Wiley Publishing, Inc., Indianapolis, Indiana Published by Wiley Publishing, Inc., Indianapolis, Indiana Published simultaneously in Canada No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except as permit- ted under Sections 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, 222 Rosewood Drive, Danvers, MA 01923, (978) 750-8400, fax (978) 646-8600. Requests to the Publisher for permission should be addressed to the Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) 748-6011, fax (201) 748-6008, or online at http:// www.wiley.com/go/permissions. Trademarks: Wiley, the Wiley Publishing logo, For Dummies, the Dummies Man logo, A Reference for the Rest of Us!, The Dummies Way, Dummies Daily, The Fun and Easy Way, Dummies.com, Making Everything Easier, and related trade dress are trademarks or registered trademarks of John Wiley & Sons, Inc. and/ or its affi liates in the United States and other countries, and may not be used without written permission. Android is a trademark of Google, Inc. All other trademarks are the property of their respective owners. Wiley Publishing, Inc., is not associated with any product or vendor mentioned in this book. LIMIT OF LIABILITY/DISCLAIMER OF WARRANTY: THE PUBLISHER AND THE AUTHOR MAKE NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE ACCURACY OR COMPLETENESS OF THE CONTENTS OF THIS WORK AND SPECIFICALLY DISCLAIM ALL WARRANTIES, INCLUDING WITH- OUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE. NO WARRANTY MAY BE CREATED OR EXTENDED BY SALES OR PROMOTIONAL MATERIALS. THE ADVICE AND STRATEGIES CONTAINED HEREIN MAY NOT BE SUITABLE FOR EVERY SITUATION. THIS WORK IS SOLD WITH THE UNDERSTANDING THAT THE PUBLISHER IS NOT ENGAGED IN RENDERING LEGAL, ACCOUNTING, OR OTHER PROFESSIONAL SERVICES. IF PROFESSIONAL ASSISTANCE IS REQUIRED, THE SERVICES OF A COMPETENT PROFESSIONAL PERSON SHOULD BE SOUGHT. NEITHER THE PUBLISHER NOR THE AUTHOR SHALL BE LIABLE FOR DAMAGES ARISING HEREFROM. THE FACT THAT AN ORGANIZA- TION OR WEBSITE IS REFERRED TO IN THIS WORK AS A CITATION AND/OR A POTENTIAL SOURCE OF FURTHER INFORMATION DOES NOT MEAN THAT THE AUTHOR OR THE PUBLISHER ENDORSES THE INFORMATION THE ORGANIZATION OR WEBSITE MAY PROVIDE OR RECOMMENDATIONS IT MAY MAKE. FURTHER, READERS SHOULD BE AWARE THAT INTERNET WEBSITES LISTED IN THIS WORK MAY HAVE CHANGED OR DISAPPEARED BETWEEN WHEN THIS WORK WAS WRITTEN AND WHEN IT IS READ. For general information on our other products and services, please contact our Customer Care Department within the U.S. at 877-762-2974, outside the U.S. at 317-572-3993, or fax 317-572-4002. For technical support, please visit www.wiley.com/techsupport. Wiley also publishes its books in a variety of electronic formats. Some content that appears in print may not be available in electronic books. Library of Congress Control Number: 2010939962 ISBN: 978-0-470-77018-4 Manufactured in the United States of America 10 9 8 7 6 5 4 3 2 1 01_9780470770184-ffirs.indd iv01_9780470770184-ffirs.indd iv 11/2/10 8:45 AM11/2/10 8:45 AM About the Authors Donn Felker is a recognized leader in the development and consultation of state-of-the-art, cutting-edge software in the mobile and Web fi elds. He is an independent consultant with over 10 years of professional experience in various markets that include entertainment, health, retail, insurance, fi nan- cial, and real estate. He is a mobile junkie, serial entrepreneur, and creative innovator in all things mobile and Web. He is the founder of Agilevent, an innovative creative development fi rm that has done work for small startups as well as Fortune 500 companies. He is a Microsoft ASP Insider, an MCTS for .NET Framework 2.0 and 3.5 Web Applications, and a certifi ed ScrumMaster. He’s a national speaker on topics that include Android, .NET, and software architecture. He is the author of the TekPub.com Introduction to Android video series. He is a writer, presenter, and consultant on various topics rang- ing from architecture to development in general, agile practices, and patterns and practices. Follow Donn on Twitter (@donnfelker) or read his blog here: http://blog.donnfelker.com. Joshua Dobbs is a senior lead Web application developer for a large elec- tronics manufacturer in Southern California. He has more than ten years’ experience in Web and desktop application development. Josh was an early adopter of the Android platform and creates Android apps in his spare time. His apps have been downloaded more than 6 million times, and he was selected by Google as top Android developer for its Device Seeding Program. His Web site is www.joshdobbs.com. 01_9780470770184-ffirs.indd v01_9780470770184-ffirs.indd v 11/2/10 8:45 AM11/2/10 8:45 AM 01_9780470770184-ffirs.indd vi01_9780470770184-ffirs.indd vi 11/2/10 8:45 AM11/2/10 8:45 AM Dedication To my dogs, Lulu and Macho, and my cat, Vito: Thanks for keeping me company in the cold basement while I cranked out page after page in the wee hours of the morning while everyone else was asleep. Writing is a lonely gig, and your company helped the time pass much easier (and kept my feet and lap warm too). To my dearest daughter, Sophia, who made even the toughest days brighter through her contagious, infectious laughter and antics. I love you. Most of all, to my gorgeous wife, Ginamarie, who has always been very sup- portive of all my crazy, harebrained ideas over the years. I would not have gotten where I am in my life if it were not for your support. I love you. 01_9780470770184-ffirs.indd vii01_9780470770184-ffirs.indd vii 11/2/10 8:45 AM11/2/10 8:45 AM 01_9780470770184-ffirs.indd viii01_9780470770184-ffirs.indd viii 11/2/10 8:45 AM11/2/10 8:45 AM Author’s Acknowledgments Thanks to coauthor Joshua Dobbs for writing the couple of chapters that I needed help with. May we both have many more successful books in the future! Thanks to Wiley Acquisitions Editor Kyle Looper for giving me a shot at writ- ing this book. I really appreciate the help, support, and insight into everything publishing-related. You’ve been a life saver on this project. Thank you. Project Editor Kathy Simpson pushed me beyond what I thought would be possible in terms of the organization of the content and readability. Thank you for being a diligent editor. Copy Editor John Edwards helped fi nd some of my most subtle mistakes, which allowed me to polish the book content even more. Thank you. Technical Editor Andre Taddeini is one of the few technical individuals I trust wholeheartedly. I’m glad you were my second pair of eyes on this project. Your sanity check of the technical accuracy of the book was outstanding. Thank you. Finally, thank you to my friend John Benda for contributing by being supportive of me and my family during this process. It’s been a long road. Now it’s your turn to write a book! 01_9780470770184-ffirs.indd ix01_9780470770184-ffirs.indd ix 11/2/10 8:45 AM11/2/10 8:45 AM Publisher’s Acknowledgments We’re proud of this book; please send us your comments at http://dummies.custhelp.com. For other comments, please contact our Customer Care Department within the U.S. at 877-762-2974, outside the U.S. at 317-572-3993, or fax 317-572-4002. Some of the people who helped bring this book to market include the following: Acquisitions and Editorial Project Editor: Kathy Simpson Acquisitions Editor: Kyle Looper Copy Editor: John Edwards Technical Editor: Andre Taddeini Editorial Manager: Jodi Jensen Editorial Assistant: Amanda Graham Sr. Editorial Assistant: Cherie Case Cartoons: Rich Tennant (www.the5thwave.com) Composition Services Project Coordinator: Sheree Montgomery Layout and Graphics: Nikki Gately, Laura Westhuis Proofreaders: Laura Bowman, Rebecca Denoncour Indexer: BIM Indexing & Proofreading Services Publishing and Editorial for Technology Dummies Richard Swadley, Vice President and Executive Group Publisher Andy Cummings, Vice President and Publisher Mary Bednarek, Executive Acquisitions Director Mary C. Corder, Editorial Director Publishing for Consumer Dummies Diane Graves Steele, Vice President and Publisher Composition Services Gerry Fahey, Vice President of Production Services Debbie Stailey, Director of Composition Services 01_9780470770184-ffirs.indd x01_9780470770184-ffirs.indd x 11/2/10 8:45 AM11/2/10 8:45 AM Contents at a Glance Introduction ................................................................ 1 Part I: The Nuts and Bolts of Android ............................7 Chapter 1: Developing Spectacular Android Applications ...........................................9 Chapter 2: Prepping Your Development Headquarters ..............................................25 Part II: Building and Publishing Your First Android Application ....................................53 Chapter 3: Your First Android Project ..........................................................................55 Chapter 4: Designing the User Interface .......................................................................93 Chapter 5: Coding Your Application ...........................................................................117 Chapter 6: Understanding Android Resources ..........................................................155 Chapter 7: Turning Your Application into a Home-Screen Widget..........................163 Chapter 8: Publishing Your App to the Android Market ..........................................187 Part III: Creating a Feature-Rich Application ............ 209 Chapter 9: Designing the Task Reminder Application ..............................................211 Chapter 10: Going a la Carte with Your Menu ............................................................231 Chapter 11: Handling User Input ..................................................................................241 Chapter 12: Getting Persistent with Data Storage .....................................................261 Chapter 13: Reminding the User with AlarmManager ...............................................291 Chapter 14: Updating the Android Status Bar ............................................................303 Chapter 15: Working with Android’s Preference Framework ..................................313 Part IV: The Part of Tens .......................................... 329 Chapter 16: Ten Great Free Sample Applications and SDKs (With Code!) .............331 Chapter 17: Ten Tools That Make Your Developing Life Easier ..............................337 Index ...................................................................... 341 02_9780470770184-ftoc.indd xi02_9780470770184-ftoc.indd xi 11/2/10 8:46 AM11/2/10 8:46 AM 02_9780470770184-ftoc.indd xii02_9780470770184-ftoc.indd xii 11/2/10 8:46 AM11/2/10 8:46 AM Table of Contents Introduction ................................................................. 1 About This Book ..............................................................................................1 Conventions Used in This Book .....................................................................2 Foolish Assumptions .......................................................................................3 How This Book Is Organized ..........................................................................3 Part I: The Nuts and Bolts of Android .................................................3 Part II: Building and Publishing Your First Android Application .....4 Part III: Creating a Feature-Rich Application ......................................4 Part IV: The Part of Tens .......................................................................4 Icons Used in This Book .................................................................................4 Where to Go from Here ...................................................................................5 Part I: The Nuts and Bolts of Android ............................ 7 Chapter 1: Developing Spectacular Android Applications . . . . . . . . . .9 Why Develop for Android? .............................................................................9 Market share .........................................................................................10 Time to market .....................................................................................10 Open platform ......................................................................................10 Cross-compatibility .............................................................................11 Mashup capability ...............................................................................11 Android Programming Basics ......................................................................13 Java: Your Android programming language .....................................13 Activities ...............................................................................................14 Intents....................................................................................................14 Cursorless controls .............................................................................15 Views and widgets ...............................................................................16 Asynchronous calls .............................................................................16 Background services ...........................................................................17 Hardware Tools .............................................................................................18 Touchscreen .........................................................................................19 GPS .........................................................................................................19 Accelerometer ......................................................................................20 SD Card ..................................................................................................20 Software Tools ...............................................................................................20 Internet ..................................................................................................21 Audio and video support ....................................................................21 Contacts ................................................................................................21 Security .................................................................................................22 Google APIs ...........................................................................................22 02_9780470770184-ftoc.indd xiii02_9780470770184-ftoc.indd xiii 11/2/10 8:46 AM11/2/10 8:46 AM Android Application Development For Dummies xiv Chapter 2: Prepping Your Development Headquarters . . . . . . . . . . . . .25 Developing the Android Developer Inside You .........................................25 Assembling Your Toolkit ..............................................................................26 Android source code ...........................................................................26 Linux 2.6 kernel ....................................................................................27 Android framework..............................................................................27 Application framework ........................................................................28 Open Handset Alliance libraries ........................................................30 Java knowledge ....................................................................................31 Tuning Up Your Hardware ...........................................................................31 Operating system .................................................................................31 Computer hardware ............................................................................32 Installing and Confi guring Your Support Tools .........................................32 Getting the Java Development Kit ...............................................................33 Downloading the JDK ..........................................................................33 Installing the JDK .................................................................................35 Acquiring the Android SDK ..........................................................................35 Downloading the Android SDK ...........................................................35 Following and setting your tools path ..............................................38 Getting the Total Eclipse ..............................................................................41 Choosing the right Eclipse version ....................................................41 Installing Eclipse ..................................................................................41 Confi guring Eclipse ..............................................................................43 Getting Acquainted with the Android Development Tools ......................47 Navigating the Android SDK ...............................................................47 Targeting Android platforms ..............................................................48 Using SDK tools for everyday development .....................................49 Part II: Building and Publishing Your First Android Application .................................... 53 Chapter 3: Your First Android Project. . . . . . . . . . . . . . . . . . . . . . . . . . . .55 Starting a New Project in Eclipse .................................................................55 Deconstructing Your Project .......................................................................61 Responding to error messages ..........................................................62 Understanding the Build Target and Min SDK Version settings ....63 Setting Up an Emulator .................................................................................65 Creating Launch Confi gurations ..................................................................68 Creating a debug confi guration ..........................................................68 Creating a run confi guration ..............................................................68 Duplicating your launch confi guration for quick setup ..................71 Running the Hello Android App ...................................................................72 Running the app in the emulator .......................................................72 Checking deployment status ..............................................................77 02_9780470770184-ftoc.indd xiv02_9780470770184-ftoc.indd xiv 11/2/10 8:46 AM11/2/10 8:46 AM xv Table of Contents Understanding Project Structure ................................................................78 Navigating the app’s folders ...............................................................78 Viewing the application’s manifest fi le .............................................88 Viewing the default.properties fi le ....................................................90 Chapter 4: Designing the User Interface . . . . . . . . . . . . . . . . . . . . . . . . .93 Creating the Silent Mode Toggle Application ............................................94 Laying Out the Application ..........................................................................95 Using the XML layout fi le ....................................................................96 Using the Android SDK’s layout tools ...............................................98 Using the visual designer ....................................................................99 Developing the User Interface ....................................................................102 Viewing XML layout attributes .........................................................102 Working with views ...........................................................................103 Adding an Image to Your Application .......................................................104 Placing an image on the screen........................................................105 Adding the image to the layout ........................................................106 Creating a Launcher Icon for the Application ..........................................108 Designing a custom launcher icon ...................................................109 Adding a custom launcher icon .......................................................110 Adding a Toggle Button Widget .................................................................111 Previewing the Application in the Visual Designer .................................113 Changing the orientation ..................................................................114 Changing the background color .......................................................114 Chapter 5: Coding Your Application . . . . . . . . . . . . . . . . . . . . . . . . . . . .117 Understanding Activities ............................................................................117 Working with methods, stacks, and states .....................................118 Tracking an activity’s life cycle ........................................................119 Creating Your First Activity .......................................................................122 Starting with onCreate ......................................................................122 Handling the bundle ..........................................................................123 Telling Android to display the UI .....................................................123 Handling user input ...........................................................................124 Writing your fi rst event handler ......................................................125 Working with the Android Framework Classes .......................................128 Getting good service ..........................................................................128 Toggling silent mode with AudioManager ......................................129 Installing Your Application .........................................................................133 Returning to the emulator ................................................................133 Installing on a physical Android device ..........................................135 Reinstalling Your Application ....................................................................137 Understanding the state of the emulator ........................................137 Doing the reinstallation .....................................................................137 Uh-oh!: Responding to Errors .....................................................................138 Using the Dalvik Debug Monitor Server ..........................................138 Using the Eclipse debugger ..............................................................143 02_9780470770184-ftoc.indd xv02_9780470770184-ftoc.indd xv 11/2/10 8:46 AM11/2/10 8:46 AM Android Application Development For Dummies xvi Thinking Beyond Your Application Boundaries ......................................151 Interacting with your application ....................................................151 Does it work?: Testing your application .........................................152 Chapter 6: Understanding Android Resources . . . . . . . . . . . . . . . . . . .155 Understanding Resources ..........................................................................155 Dimensions .........................................................................................156 Styles ...................................................................................................156 Themes ................................................................................................157 Values ..................................................................................................157 Menus ..................................................................................................157 Colors ..................................................................................................158 Working with Resources .............................................................................158 Moving strings into resources .........................................................158 Wrestling the image beast ................................................................160 Making your apps global with resources ........................................161 Chapter 7: Turning Your Application into a Home-Screen Widget. . . .163 Working with App Widgets in Android .....................................................164 Working with remote views ..............................................................165 Using AppWidgetProviders ..............................................................166 Working with Pending Intents ....................................................................167 Understanding the Android intent system .....................................167 Understanding intent data ................................................................168 Evaluating intents ..............................................................................170 Using pending intents ........................................................................170 Creating the Home-Screen Widget .............................................................172 Implementing the AppWidgetProvider ...........................................172 Communicating with the app widget ..............................................173 Building the app widget’s layout .....................................................175 Doing work inside an AppWidgetProvider .....................................176 Working with the app widget’s metadata .......................................181 Registering your new components with the manifest...................182 Placing Your Widget on the Home Screen ................................................184 Chapter 8: Publishing Your App to the Android Market . . . . . . . . . . .187 Creating a Distributable File .......................................................................187 Revisiting the manifest fi le................................................................188 Choosing your tools ..........................................................................189 Digitally signing your application ....................................................189 Creating the APK fi le ..........................................................................191 Creating an Android Market Account .......................................................194 Pricing Your Application ............................................................................200 Why to choose the paid model ........................................................200 Why to choose the free model .........................................................201 Getting Screen Shots for Your Application ..............................................201 Uploading Your Application to the Android Market ...............................203 Watching the Installs Soar ..........................................................................207 02_9780470770184-ftoc.indd xvi02_9780470770184-ftoc.indd xvi 11/2/10 8:46 AM11/2/10 8:46 AM xvii Table of Contents Part III: Creating a Feature-Rich Application ............. 209 Chapter 9: Designing the Task Reminder Application . . . . . . . . . . . .211 Reviewing the Basic Requirements ...........................................................211 That’s alarming!: Scheduling a reminder script .............................212 Storing data ........................................................................................212 Distracting the user (nicely).............................................................213 Creating the Application’s Screens ...........................................................213 Starting the new project....................................................................214 Creating the task list ..........................................................................214 Creating and editing task activities .................................................216 Creating the adding/editing layout ..................................................217 Creating Your First List Activity ................................................................220 Getting stubby with fake data ..........................................................221 Handling user click events ................................................................222 Identifying Your Intent ................................................................................224 Starting new activities with intents .................................................224 Retrieving values from previous activities .....................................225 Creating a chooser .............................................................................226 Chapter 10: Going a la Carte with Your Menu. . . . . . . . . . . . . . . . . . . .231 Seeing What Makes a Menu Great .............................................................232 Creating Your First Menu ...........................................................................232 Defi ning the XML fi le..........................................................................232 Handling user actions ........................................................................234 Creating a reminder task...................................................................235 Completing the activity .....................................................................235 Creating a Context Menu ............................................................................236 Creating the menu XML fi le ..............................................................237 Loading the menu ..............................................................................237 Handling user selections ...................................................................238 Chapter 11: Handling User Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .241 Creating the User Input Interface ..............................................................241 Creating an EditText widget .............................................................241 Displaying an on-screen keyboard ..................................................243 Getting Choosy with Dates and Times ......................................................244 Creating picker buttons ....................................................................244 Wiring up the date picker .................................................................245 Wiring up the time picker .................................................................250 Creating Your First Alert Dialog Box .........................................................252 Seeing why you should work with dialog boxes ............................253 Choosing the right dialog box for a task .........................................254 Creating your own alert dialog box .................................................255 Validating Input ...........................................................................................257 Toasting the user ...............................................................................258 Using other validation techniques...................................................258 02_9780470770184-ftoc.indd xvii02_9780470770184-ftoc.indd xvii 11/2/10 8:46 AM11/2/10 8:46 AM Android Application Development For Dummies xviii Chapter 12: Getting Persistent with Data Storage . . . . . . . . . . . . . . . .261 Finding Places to Put Data ..........................................................................261 Viewing your storage options ..........................................................262 Choosing a storage option ................................................................263 Asking the User for Permission .................................................................264 Seeing how permissions affect the user experience .....................264 Setting requested permissions in the AndroidManifest.xml fi le .....264 Creating Your Application’s SQLite Database .........................................266 Understanding how the SQLite database will work ......................266 Creating a Java fi le to hold the database code ..............................267 Defi ning the key elements .................................................................267 Visualizing the SQL table ..................................................................269 Creating the database table ..............................................................270 Closing the database .........................................................................271 Creating and Editing Tasks with SQLite ...................................................272 Inserting your fi rst task entry...........................................................272 Returning all the tasks with a cursor ..............................................281 Understanding the SimpleCursorAdapter ......................................283 Deleting a task ....................................................................................284 Updating a task...................................................................................284 Chapter 13: Reminding the User with AlarmManager. . . . . . . . . . . . .291 Seeing Why You Need AlarmManager ......................................................291 Waking Up a Process with AlarmManager ...............................................292 Creating the ReminderManager class .............................................293 Creating the OnAlarmReceiver class ...............................................295 Creating the WakeReminder-IntentService class ...........................296 Creating the ReminderService class ................................................298 Rebooting Devices .......................................................................................299 Creating a boot receiver ...................................................................300 Checking the boot receiver ..............................................................302 Chapter 14: Updating the Android Status Bar . . . . . . . . . . . . . . . . . . . .303 Deconstructing the Status Bar ...................................................................303 Viewing status bar icons ...................................................................303 Using status-bar tools to notify the user ........................................304 Using the Notifi cation Manager .................................................................307 Creating your fi rst notifi cation .........................................................307 Viewing the workfl ow ........................................................................309 Adding string resources ....................................................................310 Updating a Notifi cation ...............................................................................310 Clearing a Notifi cation ................................................................................311 Chapter 15: Working with Android’s Preference Framework . . . . . .313 Understanding Android’s Preference Framework ...................................314 Understanding the PreferenceActivity Class ...........................................314 Persisting preference values ............................................................315 Laying out preferences......................................................................316 02_9780470770184-ftoc.indd xviii02_9780470770184-ftoc.indd xviii 11/2/10 8:46 AM11/2/10 8:46 AM xix Table of Contents Creating Your First Preference Screen .....................................................317 Building the preferences fi le.............................................................317 Adding string resources ....................................................................319 Working with the PreferenceActivity Class ..............................................320 Opening the PreferenceActivity class .............................................321 Handling menu selections .................................................................322 Working with Preferences in Your Activities at Run Time .....................323 Retrieving preference values ............................................................323 Setting preference values .................................................................326 Part IV: The Part of Tens ...........................................329 Chapter 16: Ten Great Free Sample Applications and SDKs (With Code!) . . . . . . . . . . . . . . . . . . . . . . . . . . .331 The Offi cial Foursquare App ......................................................................332 LOLCat ..........................................................................................................332 Amazed .........................................................................................................333 APIDemos .....................................................................................................333 MultipleResolutions Example ....................................................................333 Last.fm App Suite .........................................................................................334 Hubroid .........................................................................................................334 Facebook SDK for Android .........................................................................334 Replica Island ...............................................................................................335 Notepad Tutorial .........................................................................................335 Chapter 17: Ten Tools That Make Your Developing Life Easier . . . .337 droid-fu .........................................................................................................337 RoboGuice ....................................................................................................338 DroidDraw ....................................................................................................338 Draw 9-patch ................................................................................................338 Hierarchy Viewer .........................................................................................338 UI/Application Exerciser Monkey ..............................................................339 zipalign ..........................................................................................................339 layoutopt ......................................................................................................339 Git ..................................................................................................................339 Paint.NET and GIMP ....................................................................................340 Index ....................................................................... 341 02_9780470770184-ftoc.indd xix02_9780470770184-ftoc.indd xix 11/2/10 8:46 AM11/2/10 8:46 AM Android Application Development For Dummies xx 02_9780470770184-ftoc.indd xx02_9780470770184-ftoc.indd xx 11/2/10 8:46 AM11/2/10 8:46 AM Introduction Welcome to Android Application Development For Dummies, the first For Dummies book that covers Android application development. When I was contacted to write this book, I was ecstatic about the opportunity to spread the wealth of knowledge that I’d picked up over the past year and a half of Android development. I hope you enjoy finding out about how to pro- gram for the Android platform from this book as much as I enjoyed writing it! When Android was acquired by Google in 2005 (yes, Android was a start-up company at one point), I’ll be honest, I didn’t have much interest in it. I heard that Google might be entering the mobile space, but as with anything in the technology industry, I didn’t believe it until I saw it firsthand. Fast-forward to a few years later, when Google announced its first Android phone: the G1. When I heard this news, I was glued to the computer, reading reviews, watch- ing videos, and researching the product as much as I could. I knew that this product would be the start of something huge. I got my start in Android development about a week after my wife received her first G1 Android device. The G1 was the first publicly released Android device. It didn’t match the rich feature set of the iPhone at the time, but I desperately believed in the platform. As soon as Donut (Android 1.6) was released, it was evident that Google was putting some effort into the product. Immediately after version 1.6 was released, talk of 2.0 was already on the horizon. Today, we’re on version 2.2 of the Android platform, and 3.0 is just around the corner. The platform is barely two years old, and I see no sign of the platform development slowing down. Without doubt, this is an exciting time in Android development. I hope that your excitement carries through as you read this book and later as you release your own applications on the market. About This Book Android Application Development For Dummies is a beginner’s guide to devel- oping Android applications. You don’t need any Android application develop- ment experience under your belt to get started. I expect you to approach this material as a blank slate because the Android platform accomplishes various mechanisms by using different paradigms that most programmers aren’t used to using — or developing with — on a day-to-day basis. I expect you to be familiar with the Java programming language, however. You don’t have to 03_9780470770184-intro.indd 103_9780470770184-intro.indd 1 11/2/10 8:46 AM11/2/10 8:46 AM 2 Android Application Development For Dummies be a Java guru, but you should understand the syntax, basic data structures, and language constructs. XML is also used in developing Android applica- tions, so I advise understanding XML as well. The Android platform is a device-independent platform, which means that you can develop applications for various devices. These devices include but aren’t limited to phones, e-book readers, netbooks, and GPS devices. Soon, television sets will join the list. Yes, you read it correctly — TV! Google has announced plans to include a Google TV offering in the Android platform. Finding out how to develop for the Android platform opens a large variety of development options for you. This book distills hundreds, if not thou- sands, of pages of Android documentation, tips, tricks, and tutorials into a short, digestible format that allows you to springboard into your future as an Android developer. This book isn’t a recipe book, but it gives you the basic knowledge to assemble various pieces of the Android framework to create interactive and compelling applications. Conventions Used in This Book Throughout the book, you use the Android framework classes, and you will be creating Java classes and XML files. Code examples in this book appear in a monospace font so that they stand out from other text in the book. This means that the code you’ll see looks like this: public class MainActivity Java is a high-level programming language that is case-sensitive, so be sure to enter the text into the editor exactly as you see it in the book. I also use the standard Java conventions in this book. Therefore, you can transition easily between my examples and the example code provided by the Android Software Development Kit (SDK). All class names, for example, appear in PascalCase format, and all class-scoped variables start with m. All the URLs in the book appear in monospace font as well: http://d.android.com If you’re ever unsure about anything in the code, you can download the full source code from my GitHub account, located at http://github.com/ donnfelker. From time to time, I provide code updates to the source. You can also find other examples in my other source repositories stored on the same site. Finally, you can find the same material on the For Dummies Web site at www.dummies.com/go/androidappdevfd. 03_9780470770184-intro.indd 203_9780470770184-intro.indd 2 11/2/10 8:46 AM11/2/10 8:46 AM 3 Introduction Foolish Assumptions To begin programming with Android, you need a computer that runs one of the following operating systems: ✓ Windows XP (32 bit), Vista (32 or 64 bit), or Windows 7 (32 or 64 bit) ✓ Mac OS X (Intel) 10.5.8 (x86 only) ✓ Linux (i386) You also need to download the Android SDK (which is free) and the Java Development Kit (or JDK, which is also free), if you don’t already have them on your computer. I explain the entire installation process for all the tools and frameworks in Chapter 2. As I state earlier in this introduction, because Android applications are devel- oped in the Java programming language, you need to understand the Java language. Android also uses XML quite heavily to define various resources inside the application, so you should understand XML too. I don’t expect you to be an expert in these languages, however. I started in Android with a back- ground in C#, having done Java only in college nearly 10 years earlier, and I fared just fine. You don’t need a physical Android device, because all the applications you build in this book work on the emulator. I highly recommend developing on a real device, however, because it allows you to interact with your applications as real users would. How This Book Is Organized Android Application Development For Dummies has four parts, which I describe in the following sections. Part I: The Nuts and Bolts of Android Part I introduces the tools and frameworks that you use to develop Android applications. It also introduces the various SDK components and shows you how they’re used in the Android ecosystem. 03_9780470770184-intro.indd 303_9780470770184-intro.indd 3 11/2/10 8:46 AM11/2/10 8:46 AM 4 Android Application Development For Dummies Part II: Building and Publishing Your First Android Application Part II introduces you to building your first Android application: the Silent Mode Toggle application. After you build the initial application, I show you how to create an app widget for the application that you can place on the home screen of the Android device. I tie everything together by demonstrat- ing how to publish your application to the Android Market. Part III: Creating a Feature-Rich Application Part III takes your development skills up a notch by walking you through the construction of the Task Reminder application, which allows users to create various tasks with reminders. I cover the implementation of an SQLite data- base in this multiscreen application. You also see how to use the Android status bar to create notifications that can help increase the usability of your application. Part IV: The Part of Tens Part IV brings together the prizes that I’ve found through my trials and tribu- lations in Android development. I give you a tour of sample applications that prove to be stellar launching pads for your Android apps, and I introduce useful Android libraries that can make your Android development career a lot easier. Icons Used in This Book This icon indicates a useful pointer that you shouldn’t skip. This icon represents a friendly reminder about a vital point you should keep in mind while proceeding through a particular section of the chapter. 03_9780470770184-intro.indd 403_9780470770184-intro.indd 4 11/2/10 8:46 AM11/2/10 8:46 AM 5 Introduction This icon signifies that the accompanying explanation may be informative but isn’t essential to understanding Android application development. Feel free to skip these snippets, if you like. This icon alerts you to potential problems that you may encounter along the way. Read and remember these tidbits to avoid possible trouble. Where to Go from Here It’s time to explore the Android platform! If you’re a bit nervous, let me assure you that you don’t have to worry; you should be nervous only because you’re excited. 03_9780470770184-intro.indd 503_9780470770184-intro.indd 5 11/2/10 8:46 AM11/2/10 8:46 AM 6 Android Application Development For Dummies 03_9780470770184-intro.indd 603_9780470770184-intro.indd 6 11/2/10 8:46 AM11/2/10 8:46 AM Part I The Nuts and Bolts of Android 04_9780470770184-pp01.indd 704_9780470770184-pp01.indd 7 11/2/10 8:46 AM11/2/10 8:46 AM In this part . . . Part I introduces you to the Android platform and describes what makes a spectacular Android applica- tion. I briefly explore various parts of the Android software development kit (SDK) and explain how you can use them in your applications. I also guide you through the process of installing the tools and frameworks necessary to develop Android applications. 04_9780470770184-pp01.indd 804_9780470770184-pp01.indd 8 11/2/10 8:46 AM11/2/10 8:46 AM Chapter 1 Developing Spectacular Android Applications In This Chapter ▶ Seeing reasons to develop Android apps ▶ Starting with the basics of Android programming ▶ Working with the hardware ▶ Getting familiar with the software Google rocks! Google acquired the Android project in 2005 (see the side- bar “The roots of Android” later in this chapter) to ensure that a mobile operating system (OS) could be created and maintained in an open platform. Google continues to pump time and resources into the Android project, which has already proved to be beneficial. As of July 2010, 160,000 Android handsets have been activated daily, which is good considering that handsets have been available only since October 2008. That’s less than two years, and Android has already made a huge impact! It has never been easier for a developer to be able to make money on his own. Android users may not know who you are, but they know what Google is, and they trust Google. Because your app resides in the Android Market — which Google controls — Google assumes that your application is okay too. Why Develop for Android? Well, the real question should be “Why not?” Do you want your app to be available to millions of users worldwide? Do you want to publish apps as soon as you’re done writing and testing them? Do you like developing on open platforms? If you answered yes to any of these questions, I think you have your answer, but in case you’re still undecided, keep reading, and I’ll explain what I mean. 05_9780470770184-ch01.indd 905_9780470770184-ch01.indd 9 11/2/10 8:51 AM11/2/10 8:51 AM 10 Part I: The Nuts and Bolts of Android Market share As a developer, you have an opportunity to develop apps for a fairly new market that is booming on a daily basis. Android is currently set to outpace many other carriers in market share in the industry in coming months. With so many users, it’s never been easier to write an application that can be downloaded and used by real people! The Android Market puts your app right into your users’ hands easily! Users don’t have to go searching the Internet to find an app to install. They just simply go to the Android Market that is preinstalled on their device, and they have access to all your apps. Because the Android Market comes preinstalled on most Android devices (I discuss a few exceptions later), users typically search the Android Market for all of their app needs. It’s not hard to see an app’s number of downloads soar in just a few days. Time to market With all the application programming interfaces (APIs) that Android comes packed with, it’s easy to develop full-featured applications in a relatively short time frame. After you’ve signed up with the Android Market, just upload your apps and publish them. “Wait,” you may say, “are you sure?” Why, yes, I am! Unlike other mobile marketplaces, the Android Market has no app-approval process. All you have to do is write apps and publish them. Technically, anyone can publish anything, but it’s good karma to keep within Google’s terms of service and keep your apps family-friendly. Remember that Android users come from diverse areas of the world and are in all age categories. Open platform The Android operating system is open platform, meaning that it’s not tied to one hardware manufacturer and/or one provider. As you can imagine, the openness of Android is allowing it to gain market share quickly. All hard- ware manufacturers and providers can make and sell Android devices. The Android source code is available at http://source.android.com for you to view and/or modify. Nothing is holding you back from digging into the source code to see how a certain task is handled. The open-source code allows phone manufacturers to create custom user interfaces (UIs) and add built-in features to some devices. This also puts all developers on an even playing field. Everyone can access the raw Android source code. 05_9780470770184-ch01.indd 1005_9780470770184-ch01.indd 10 11/2/10 8:51 AM11/2/10 8:51 AM 11 Chapter 1: Developing Spectacular Android Applications Cross-compatibility Android can run on many devices with different screen sizes and resolutions. Besides being cross-compatible, Android comes with the tools that help you develop cross-compatible applications. Google allows your apps to run only on compatible devices. If your app requires a front-facing camera, for exam- ple, only phones with a front-facing camera will be able to see your app in the Android Market. This arrangement is known as feature detection. (For more information on publishing your apps to the Android Market, see Chapter 8.) For Android devices to be certified compatible (devices have to be compat- ible to have access to the Android Market), they must follow certain hardware guidelines. These guidelines include but are not limited to the following: ✓ Camera ✓ Compass ✓ GPS (Global Positioning System) feature ✓ Bluetooth transceiver See the Compatibility Program Overview page at http://source. android.com/compatibility/overview.html for specific device con- figurations that are considered to be compatible. Compatibility ensures that your apps can run on all devices. Mashup capability A mashup combines two or more services to create an application. You can create a mashup by using the camera and Android’s location services, for example, to take a picture with the exact location displayed on the image! It’s easy to make a ton of apps by combining services or libraries in new and exciting ways. The roots of Android Most people don’t know this, but Google didn’t start the Android project. The initial Android operating system was created by a small start- up company in Silicon Valley known as Android, Inc., which was purchased by Google in July 2005. The founders of Android, Inc., came from various Internet technology companies such as Danger, Wildfire Communications, T-Mobile, and WebTV. Google brought them into the Google team to help create what is now the full-fledged Android mobile operating system. 05_9780470770184-ch01.indd 1105_9780470770184-ch01.indd 11 11/2/10 8:51 AM11/2/10 8:51 AM 12 Part I: The Nuts and Bolts of Android With all the APIs that Android includes, it’s easy to use two or more of these features to make your own app. You can use a maps API with the contact list to show all your contacts on a map, for example (see “Google APIs,” later in this chapter). Here are a few other mashups to get your brain juices pumping. All this stuff is included for you to use, and it’s completely legal and free! ✓ Geolocation and social networking: Social networking is the “in” thing right now. Suppose you want to write an app that tweets your current location every 10 minutes throughout the day. You can, and it’s easy. Use Android’s location services and a third-party Twitter API (such as iTwitter), and you can do just that. ✓ Geolocation and gaming: Location-based gaming is gaining popularity. It’s a great way to really put your users into the game. A game might run a background service to check your current location and compare it with the locations of other users of the game in the same area. If another user is within 1 mile of you, for example, you could be notified, and you could challenge her to a battle. None of this would be possible without a strong platform such as Android and GPS technology. ✓ Contacts and Internet: With all these cool APIs at your disposal, it’s easy to make full-featured apps by combining the functionality of two or more APIs. You can combine contacts and the Internet to create a greeting-card app, for example. Or you may just want to add an easy way for your users to contact you from an app or enable users to send the app to their friends. This is all possible with the built-in APIs. The sky is the limit. All this cool functionality is literally in the palm of your hand. If you want to develop an app that records the geographic location of the device, you can with ease. Android really opens the possibilities by allow- ing you to tap into these features easily. It’s up to you, as the developer, to put them together in a way that can benefit your users. Developers can do just about anything they want with Android, so be careful. Use your best judgment when creating and publishing apps for mass con- sumption. Just because you want a live wallpaper that shows you doing the hula in your birthday suit doesn’t mean that anyone else wants to see it. Also, keep privacy laws in mind before you harvest your users’ contact info for your own marketing scheme. 05_9780470770184-ch01.indd 1205_9780470770184-ch01.indd 12 11/2/10 8:51 AM11/2/10 8:51 AM 13 Chapter 1: Developing Spectacular Android Applications Android Programming Basics You don’t have to be a member of Mensa to program Android applications. I’m glad, because otherwise, I wouldn’t be writing them! Programming for Android is simple because the default programming language of Android is Java. Although writing Android applications is fairly easy, programming in itself can be a difficult task to conquer. If you’ve never programmed before, this book may not be the best place to start. I advise that you pick up a copy of Beginning Programming with Java For Dummies, by Barry Burd (Wiley Publishing), to learn the ropes. After you have a basic understanding of Java under your belt, you should be ready to tackle this book. Although the majority of Android is Java, small parts of the framework aren’t. Android also encompasses the XML language as well as basic Apache Ant scripting for build processes. I advise you to have a basic understanding of XML before delving into this book. If you need an introduction to XML, check out XML For Dummies, by Lucinda Dykes and Ed Tittel (Wiley). If you already know Java and XML, congratulations — you’re ahead of the curve! Java: Your Android programming language Android applications are written in Java — not the full-blown Java that J2EE developers are used to, but a subset of Java that is sometimes known as the Dalvik virtual machine. This smaller subset of Java excludes classes that don’t make sense for mobile devices. If you have any experience in Java, you should be right at home. It may be a good idea to keep a Java reference book on hand, but in any case, you can always Google what you don’t understand. Because Java is nothing new, you can find plenty of examples on the Web that demonstrate how to do just about anything. In Java source code, not all libraries are included. Verify that the package is available to you. If it’s not, an alternative is probably bundled with Android that can work for your needs. 05_9780470770184-ch01.indd 1305_9780470770184-ch01.indd 13 11/2/10 8:51 AM11/2/10 8:51 AM 14 Part I: The Nuts and Bolts of Android Activities Android applications are made up of one or more activities. Your app must contain at least one activity, but an Android application can contain several. Think of an activity as being a container for your UI, holding your UI as well as the code that runs it. It’s kind of like a form, for you Windows program- mers out there. I discuss activities in more detail in Chapters 3 and 5. Intents Intents make up the core message system that runs Android. An intent is composed of an action that it needs to perform (View, Edit, Dial, and so on) and data. The action is the general action to be performed when the intent is received, and the data is the data to operate on. The data might be a contact item, for example. Intents are used to start activities and to communicate among various parts of the Android system. Your application can either broadcast an intent or receive an intent. Sending messages with intents When you broadcast an intent, you’re sending a message telling Android to make something happen. This intent could tell Android to start a new activity from within your application, or it could start a different application. Registering intent receivers Just because you send a message doesn’t mean that something will happen automatically. You have to register an intent receiver that listens for the intent and then tells Android what to do, whether the task is starting a new activity or starting a different app. If many receivers can accept a given intent, a chooser can be created to allow the user to pick the app she wants to use. A classic example is long-pressing an image in an image gallery. Long- pressing means clicking something for a long time to bring up a context menu. By default, various registered receivers handle the image-sharing intents. One of many is e-mail, and another is the messaging application (among various other installed applications). Because you find more than one possible intent receiver, the user is presented with a chooser asking him what he should do: use e-mail, messaging, or another application, as shown in Figure 1-1. 05_9780470770184-ch01.indd 1405_9780470770184-ch01.indd 14 11/2/10 8:51 AM11/2/10 8:51 AM 15 Chapter 1: Developing Spectacular Android Applications Figure 1-1: A chooser. If the Android system cannot find a match for the intent that was sent, and a chooser was not created manually, the application will crash due to a run-time exception: an unhandled error in the application. Android expects developers to know what they’re doing. If you send an intent that a user’s Android device doesn’t know how to handle, the device crashes. It’s best practice to create choosers for intents that don’t target other activities within your application. Cursorless controls Unlike PCs, which let you use a mouse to move the cursor across the screen, Android devices let you use your fingers to do just about anything a mouse can do. But how do you right-click? Instead of supporting right-clicking, Android has implemented the long press. Press and hold a button, icon, or screen for an extended period of time, and a context menu appears. As a developer, you can create and manipulate context menus. You can allow users to use two fingers on an Android device instead of just one mouse cursor, for example. Keep in mind that fingers come in all sizes, however, and design your user interface accordingly. Make the buttons large enough, with enough spacing, so that even users with large fingers can interact with your apps easily. 05_9780470770184-ch01.indd 1505_9780470770184-ch01.indd 15 11/2/10 8:51 AM11/2/10 8:51 AM 16 Part I: The Nuts and Bolts of Android Views and widgets What the heck is a view? A view is a basic UI element — a rectangular area on the screen that is responsible for drawing and event handling. I like to think of views as being basic controls, such as a label control in HTML. Here are a few examples of views: ✓ ContextMenu ✓ Menu ✓ View ✓ Surface view Widgets are more-advanced UI elements, such as check boxes. Think of them as being the controls that your users interact with. Here are a few widgets: ✓ Button ✓ CheckBox ✓ DatePicker ✓ DigitalClock ✓ Gallery ✓ FrameLayout ✓ ImageView ✓ RelativeLayout ✓ PopupWindow Many more widgets are ready for you to use. Check out the android. widget package in the Android documentation at http://developer. android.com/reference/android/widget/package-summary.html for complete details. Asynchronous calls Who called? I don’t know anybody named Asynchronous, do you? The AsyncTask class in Android allows you to run multiple operations at the same time without having to manage a separate thread yourself. AsyncTask not only lets you start a new process without having to clean up after your- self, but also returns the result to the activity that started it. This allows you to have a clean programming model for asynchronous processing. 05_9780470770184-ch01.indd 1605_9780470770184-ch01.indd 16 11/2/10 8:51 AM11/2/10 8:51 AM 17 Chapter 1: Developing Spectacular Android Applications A thread is a process that runs separately from and simultaneously with every- thing else that’s happening. When would you use asynchronous processing? I’m glad you asked! You’d use asynchronous processing for tasks that take a long time — network com- munication (Internet), media processing, or anything else that might make the user wait. If the user has to wait, you should use an asynchronous call and some type of UI element to let him know that something is happening. Failing to use an asynchronous programming model can cause users of your application to believe that your application is buggy. Downloading the latest Twitter messages via the Internet takes time, for example. If the network gets slow, and you’re not using an asynchronous model, the application will lock up, and the user will assume that something is wrong because the application isn’t responding to her interactions. If the application doesn’t respond within a reasonable time that the Android OS defines, Android presents an “applica- tion not responding” (ANR) dialog box, as shown in Figure 1-2. At that time, the user can decide to wait or to close the application. Figure 1-2: An ANR dialog box. It’s best practice to run CPU-expensive or long-running code inside another thread, as described in the Designing for Responsiveness page on the Android developer site (http://developer.android.com/guide/practices/ design/responsiveness.html). Background services If you’re a Windows user, you may already know what a service is: an applica- tion that runs in the background and doesn’t necessarily have a UI. A classic example is an antivirus application that usually runs in the background as a service. Even though you don’t see it, you know that it’s running. 05_9780470770184-ch01.indd 1705_9780470770184-ch01.indd 17 11/2/10 8:51 AM11/2/10 8:51 AM 18 Part I: The Nuts and Bolts of Android Most music players that can be downloaded from the Android Market run as background services. This is how you can listen to music while checking your e-mail or performing another task that requires the use of the screen. Hardware Tools Google exposes a plethora of functionality in Android, thus giving developers (even the independent guys) the tools needed to create top-notch, full- featured mobile apps. Google has gone above and beyond by making it simple to tap into and make use of all the devices’ available hardware. To create a spectacular Android app, you should take advantage of all that the hardware has to offer. Don’t get me wrong: If you have an idea for an app that doesn’t need hardware assistance, that’s okay too. Android phones come with several hardware features that you can use to build your apps, as shown in Table 1-1. Table 1-1 Android Device Hardware Functionality Required Hardware Where am I? GPS radio Which way am I walking? Built-in compass Is my phone facing up or down? Proximity sensor Is my phone moving? Accelerometer Can I use my Bluetooth headphones? Bluetooth radio How do I record video? Camera Most Android phones are released with the hardware that I discuss in the following sections, but not all devices are created equal. Android is free for hardware manufacturers to distribute, so it’s used in a wide range of devices, including some made by small manufacturers overseas (and it’s not uncom- mon for some of these phones to be missing a feature or two). Also, as the technology advances, phone manufacturers are starting to add features that aren’t yet natively supported by Android. But don’t worry; man- ufacturers that add hardware usually offer a software development kit (SDK) that lets developers tap into the device’s unique feature. At this writing, HTC’s Evo 4G, available from Sprint, is the only Android phone that comes 05_9780470770184-ch01.indd 1805_9780470770184-ch01.indd 18 11/2/10 8:51 AM11/2/10 8:51 AM 19 Chapter 1: Developing Spectacular Android Applications with a front-facing camera. Because this device is the first of its kind, Sprint has released an SDK that developers can use to access this cool new feature, as well as sample code that lets them implement the feature easily. Android devices come in all shapes and sizes: phones, tablet computers, and e-book readers. You will find many other implementations of Android in the future, such as Google TV — an Android-powered home appliance — as well as cars with built-in Android-powered touchscreen computers. The engineers behind Android provide tools that let you easily deploy apps for multiple screen sizes and resolutions. Don’t worry — the Android team has done all the hard work for you. I cover the basics of screen sizes and densities in Chapter 4. Touchscreen Android phones have touchscreens, a fact that opens a ton of possibilities and can enhance users’ interaction with your apps. Users can swipe, flip, drag, and pinch to zoom, for example, by moving a finger or fingers on the touchscreen. You can even use custom gestures for your app, which opens even more possibilities. Android also supports multitouch, which means that the entire screen is touchable by more than one finger at a time. Hardware buttons are old news. You can place buttons of any shape any- where on the screen to create the UI that’s best suited for your app. GPS The Android OS combined with a phone’s GPS radio allows developers to access a user’s location at any given moment. You can track a user’s move- ment as she changes locations. The Foursquare social-networking app is a good example; it uses GPS to determine the phone’s location and then accesses the Web to determine which establishment or public place the user is in or near. Another great example is the Maps application’s ability to pinpoint your loca- tion on a map and provide directions to your destination. Android combined with GPS hardware gives you access to the phone’s exact GPS location. Many apps use this functionality to show you where the nearest gas station, coffee- house, or even restroom is located. You can even use the maps API to pin- point the user’s current location on a map. 05_9780470770184-ch01.indd 1905_9780470770184-ch01.indd 19 11/2/10 8:51 AM11/2/10 8:51 AM 20 Part I: The Nuts and Bolts of Android Accelerometer Android comes packed with accelerometer support. An accelerometer is a device that measures acceleration. That sounds cool and all, but what can you do with it? If you want to know whether the phone is moving or being shaken, or even the direction in which it’s being turned, the accelerometer can tell you. You may be thinking, “Okay, but why do I care whether the phone is being shaken or turned?” Simple! You can use that input as a way to control your application. You can do simple things like determine whether the phone has been turned upside down and do something when it happens. Maybe you’re making a dice game and want to immerse your users in the game play by having them shake the phone to roll the dice. This is the kind of functionality that is setting mobile devices apart from typical desktop personal computers. SD Card Android gives you the tools you need to access (save and load) files on the device’s SD Card — a portable storage medium that you can insert into vari- ous phones and computers. If a device is equipped with an SD Card, you can use it to store and access files needed by your application. Android 2.2 allows you to install apps on the SD Card, but maybe your users have phones that don’t get Android 2.2. Just because some users don’t have the option of installing apps on the SD Card doesn’t mean that you have to bloat your app with 20MB of resources and hog the phone’s limited built-in memory. You can download some or all of your application’s resources from your Web host and save them to the phone’s SD Card. This makes your users happy and less likely to uninstall your app when space is needed. Not all devices come with an SD Card installed, although most do. Always make sure that the user has an SD Card installed and that adequate space is available before trying to save files to it. Software Tools Various Android tools are at your disposal while writing Android applica- tions. In the following sections, I outline some of the most popular tools that you will use in your day-to-day Android development process. 05_9780470770184-ch01.indd 2005_9780470770184-ch01.indd 20 11/2/10 8:51 AM11/2/10 8:51 AM 21 Chapter 1: Developing Spectacular Android Applications Internet Thanks to the Internet capabilities of Android devices, real-time information is easy to obtain. As a user, you can use the Internet to see what time the next movie starts or when the next commuter train arrives. As a developer, you can use the Internet in your apps to access real-time, up-to-date data such as weather, news, and sports scores. You can also use the Web to store some of your application’s assets, which is what Pandora and YouTube do. Don’t stop there. Why not offload some of your application’s intense pro- cesses to a Web server when appropriate? This can save a lot of processing time in some cases and also helps keep your Android app streamlined. This arrangement is called client–server computing — a well-established software architecture in which the client makes a request to a server that is ready and willing to do something. The built-in Maps app is an example of a client access- ing map and GPS data from a Web server. Audio and video support The Android OS makes including audio and video in your apps a breeze. Many standard audio and video formats are supported. Including multime- dia content in your apps couldn’t be any easier. Sound effects, instructional videos, background music, streaming video, and audio from the Internet can all be added to your app with little to no pain. Be as creative as you want to be. The sky is the limit. Contacts Your app can access user contacts that are stored on the phone. You can use this feature to display the contacts in a new or different way. Maybe you don’t like the built-in Contacts application. With the ability to access the con- tacts stored on the phone, nothing is stopping you from writing your own. Maybe you write an app that couples the contacts with the GPS system and alerts the user when she is close to one of the contacts’ addresses. Use your imagination, but be responsible. You don’t want to use contacts in a malicious way (see the next section). 05_9780470770184-ch01.indd 2105_9780470770184-ch01.indd 21 11/2/10 8:51 AM11/2/10 8:51 AM 22 Part I: The Nuts and Bolts of Android Security Android allows your apps to do a lot! Imagine if someone released an app that went through the contact list and sent the entire list to a server some- where for malicious purposes. This is why most of the functions that modify the user’s device or access its protected content need to have permissions to work. Suppose that you want to download an image from the Web and save it to the SD Card. To do so, you need to get permission to use the Internet so that you can download the file. You also need permission to save files to the SD Card. Upon installation of the application, the user is notified of the permissions that your app is requesting. At that point, the user can decide whether he wants to proceed with the installation. Asking for permission is as easy as implementing one line of code in your application’s manifest file, which I cover in Chapter 3. Google APIs The Android OS isn’t limited to making phone calls, organizing contacts, or installing apps. You have much more power at your fingertips. As a devel- oper, you can integrate maps into your application. To do so, you have to use the maps APIs that contain the map widgets. Pinpointing locations on a map Perhaps you want to write an app that displays your current location to your friends. You could spend hundreds of hours developing a mapping system — or you could just use the Android Maps API. Google provides the Android Maps API, which you can use in your app, and just like everything else in Android, it’s free! You can embed and use the API in your application to show your friends where you are; it won’t take hundreds of hours or cost you a cent. Imagine all the juicy map goodness with none of the work developing it. Using the maps API, you can find just about anything with an address; the possibilities are endless. Display your friend’s location, the nearest grocery store, or the nearest gas station — anything or anyplace with an address. Getting around town with navigation Showing your current location to your friends is cool, but wait — there’s more! The Android Maps API can also access the Google Navigation API. Now you can pinpoint your location and also show your users how to get to that location. 05_9780470770184-ch01.indd 2205_9780470770184-ch01.indd 22 11/2/10 8:51 AM11/2/10 8:51 AM 23 Chapter 1: Developing Spectacular Android Applications Messaging in the clouds You may be thinking — clouds, I don’t see a cloud in the sky! Well, I’m not talking about those kinds of clouds. The Android Cloud to Device Messaging framework allows you to send a notification from your Web server to your app. Suppose that you store your application’s data in the cloud and down- load all the assets the first time your app runs. But what if you realize after the fact that one of the images is incorrect? For the app to update the image, it needs to know that the image changed. You can send a cloud-to-device message (a message from the Web to the device) to your app, letting it know that it needs to update the image. This works even if your app is not running. When the device receives the message, it dispatches a message to start your app so that it can take the appropriate action. The KISS principle It’s easy to overthink and overcomplicate things when developing applications. The hardest part is to remember the KISS (Keep It Simple, Stupid) principle. One way to overly complicate your code is to just dive in without understanding all the built-in APIs and knowing what they do. You can go that route, but doing so may take more time than just glossing over the Android documentation. You don’t have to memorize it, but do yourself a favor and take a look at the documentation. You’ll be glad you did when you see how easy it is to use the built-in functional- ity and how much time it can save you. You can easily write multiple lines of code to do some- thing that takes only one line. Changing the volume of the media player or creating a menu is a simple process, but if you don’t know the APIs, you may end up rewriting them and in the end causing yourself problems. When I started with my first app, I just dived in and wrote a bunch of code that managed the media player’s volume. If I’d just looked into the Android documentation a little more, I’d have known that I could handle this with one line of code that’s strategically placed inside my application. The same thing goes for the menu. I wrote a lot of code to create a menu, and if I’d only known that a menu framework already existed, it would have saved me several hours. Another way to really muck things up is to add functionality that isn’t needed. Most users want the easiest way to do things, so don’t go making some fancy custom tab layout when a couple of menu items will suffice. Android comes with enough built-in controls (widgets) that you can use to accomplish just about anything. Using the built-in controls makes your app that much easier for your users to figure out because they already know and love these controls. 05_9780470770184-ch01.indd 2305_9780470770184-ch01.indd 23 11/2/10 8:51 AM11/2/10 8:51 AM 24 Part I: The Nuts and Bolts of Android 05_9780470770184-ch01.indd 2405_9780470770184-ch01.indd 24 11/2/10 8:51 AM11/2/10 8:51 AM Chapter 2 Prepping Your Development Headquarters In This Chapter ▶ Becoming an Android application developer ▶ Collecting your tools of the trade ▶ Downloading and installing the Android SDK ▶ Getting and configuring Eclipse ▶ Working with the Android ADT All the software that you need to develop Android applications is free! That’s where the beauty of developing Android applications lies. You’ll be happy to find out that the basic building blocks you need to develop rich Android applications — the tools, the frameworks, and even the source code — are free. No, you don’t get a free computer out of it, but you do get to set up your development environment and start developing applications for free, and you can’t beat free. Well, maybe you can — such as someone paying you to write an Android application, but you’ll get there soon enough. In this chapter, I walk you through the necessary steps to get the tools and frameworks installed so that you can start building kick-butt Android applications. Developing the Android Developer Inside You Becoming an Android developer isn’t a complicated task. Actually, it’s a lot simpler than you probably think. To see what’s involved, ask yourself these questions: 06_9780470770184-ch02.indd 2506_9780470770184-ch02.indd 25 11/2/10 8:51 AM11/2/10 8:51 AM 26 Part I: The Nuts and Bolts of Android ✓ Do I want to develop Android applications? ✓ Do I like free software development tools? ✓ Do I like to pay no developer fees? ✓ Do I have a computer to develop on? If you answered yes to all these questions, today is your lucky day; you’re ready to become an Android developer. You may be wondering about the “no fees” part. Yep, you read that correctly: You pay no fees to develop Android applications. There’s always a catch, right? You can develop for free to your heart’s con- tent, but as soon as you want to publish your application to the Android Market — where you upload and publish your apps — you need to pay a small nominal registration fee. At this writing, the fee is $25. Just to ease your mind about fees, it’s important to note that if you’re devel- oping an application for a client, you can publish your application as a redis- tributable package that you can give him. Then your client can publish the application to the Android Market, using his Market account. This ensures that you don’t have to pay a fee for client work — which means that you can be a bona fide Android developer and never have to pay a fee. Now, that’s cool. Assembling Your Toolkit Now that you know you’re ready to be an Android developer, grab your com- puter and get cracking on installing the tools and frameworks necessary to build your first blockbuster application. Android source code You should be aware that the full Android source code is open source, which means that it’s not only free to use, but also free to modify. If you’d like to download the Android source code and create a new version of Android, you’re free to do so. Check the Android Git repository. You can also down- load the source code at http://source.android.com. 06_9780470770184-ch02.indd 2606_9780470770184-ch02.indd 26 11/2/10 8:51 AM11/2/10 8:51 AM 27 Chapter 2: Prepping Your Development Headquarters Linux 2.6 kernel Android was created on top of the open-source Linux 2.6 kernel. The Android team chose to use this kernel because it provided proven core features to develop the Android operating system on. The features of the Linux 2.6 kernel include (but aren’t limited to) the following: ✓ Security model: The Linux kernel handles security between the applica- tion and the system. ✓ Memory management: The kernel handles memory management for you, leaving you free to develop your app. ✓ Process management: The Linux kernel manages processes well, allocat- ing resources to processes as they need them. ✓ Network stack: The Linux kernel also handles network communication. ✓ Driver model: The goal of Linux is to ensure that everything works. Hardware manufacturers can build their drivers into the Linux build. You can see a good sampling of the Linux 2.6 feature set in Figure 2-1. Figure 2-1: Some of the Linux kernel features. Android framework Atop the Linux 2.6 kernel, the Android framework was developed with various features. These features were pulled from numerous open-source projects. The output of these projects resulted in the following: ✓ The Android run time: The Android run time is composed of Java core libraries and the Dalvik virtual machine. ✓ Open GL (graphics library): This cross-language, cross-platform appli- cation program interface (API) is used to produce 2D and 3D computer graphics. ✓ WebKit: This open-source Web browser engine provides the functional- ity to display Web content and simplify page loading. 06_9780470770184-ch02.indd 2706_9780470770184-ch02.indd 27 11/2/10 8:51 AM11/2/10 8:51 AM 28 Part I: The Nuts and Bolts of Android ✓ SQLite: This open-source relational database engine is designed to be embedded in devices. ✓ Media frameworks: These libraries allow you to play and record audio and video. ✓ Secure Sockets Layer (SSL): These libraries are responsible for Internet security. See Figure 2-2 for a list of common Android libraries. Figure 2-2: Android and other third-party libraries sit atop the Linux 2.6 kernel. Application framework You’re probably thinking, “Well, that’s all nice and well, but how do these libraries affect me as a developer?” It’s simple: All these open-source frame- works are available to you through Android. You don’t have to worry about how Android interacts with SQLite and the surface manager; you just use them as tools in your Android tool belt. The Android team has built on a known set of proven libraries and has given them to you, all exposed through Android interfaces. These interfaces wrapped up the various libraries and made them useful to the Android platform as well as useful to you as a devel- oper. Android has all these libraries built in the background and exposes these features to you without your having to build any of the functionality that they provide: ✓ Activity manager: Manages the activity life cycle. ✓ Telephony manager: Provides access to telephony services as well as some subscriber information, such as phone numbers. ✓ View system: Handles the views and layouts that make up your user interface (UI). ✓ Location manager: Finds out the device’s geographic location. 06_9780470770184-ch02.indd 2806_9780470770184-ch02.indd 28 11/2/10 8:51 AM11/2/10 8:51 AM 29 Chapter 2: Prepping Your Development Headquarters Take a look at Figure 2-3 to see the libraries that make up the application framework. Figure 2-3: A glimpse at part of the Android application framework. From kernel to application, the Android operating system has been devel- oped with proven open-source technologies. This allows you, as a developer, to build rich applications that have been fostered in the open-source com- munity. See Figure 2-4 for a full picture of how the Android application frame- work stacks up. Figure 2-4: How the Android application framework stacks up. The Applications section is where your application sits. Sometimes when developing an Android application, you’d like to use the same resource as in the core Android system. A good example would be an icon for a Settings menu option. By accessing the Android source code, you can browse the various resources and download the resources you need for your project. Having access to the source code also allows you to dig in and see exactly how Android does what it does. 06_9780470770184-ch02.indd 2906_9780470770184-ch02.indd 29 11/2/10 8:51 AM11/2/10 8:51 AM 30 Part I: The Nuts and Bolts of Android Open Handset Alliance libraries Huh? I didn’t join any “alliance”; what’s this about? Don’t worry; you’re not going to have to use the force to battle the unwieldy Darth Vader. It’s not that big of a deal, and actually it’s kind of cool. It’s kind of like a bunch of really smart companies combining efforts to achieve the same goal. The Open Handset Alliance (OHA) was announced in November 2007. At the time, the alliance consisted of 34 members, led by Google. The OHA currently has 71 members. It’s a group of technology and mobile companies that have come together to pursue innovation in the mobile field. The goal is to provide users comprehensive, compelling, and useful handsets. You can read more about the group at www.openhandsetalliance.com. Now that’s cool! The alliance has a lot of brilliant companies that are com- bining their efforts to make the mobile world a better place. They include T-Mobile, Sprint, LG, Motorola, HTC, NVidia, and Texas Instruments. You should be aware of the OHA because all the libraries that comprise the Android operating system (OS) are based on open-source code. Each member contributes in its own special way. Chip manufacturers ensure that chipsets support the platform; hardware manufacturers build devices; and other companies contribute intellectual property (code, documentation, and so on). The goal is to make Android a commercial success. As these members contribute, they also start to innovate on the Android plat- form. Some of this innovation makes it back into the Android source code, and some of it remains the intellectual property of the alliance members as decided by the OHA. Just because one device has a fancy doohickey on it doesn’t mean that another device will. The only thing that you can count on as a developer is the core Android framework. OHA members may have added an extra library to help facilitate something on a device, but there’s no guarantee that this library will be available on another device in, say, Turkey or England. An exception occurs if you’re developing for a particular device, and only that device, such as an e-book reader. If that hardware has the sole function of reading books, you can program it for just such a purpose. A real-world example of an e-book reader is the Barnes & Noble Nook, which is powered by Android. It has special Forward and Back buttons that other Android devices don’t have. Therefore, you’d program for these buttons because this device is a special case (if you’re developing for the Nook), but you can’t expect these buttons to be used on other devices. 06_9780470770184-ch02.indd 3006_9780470770184-ch02.indd 30 11/2/10 8:51 AM11/2/10 8:51 AM 31 Chapter 2: Prepping Your Development Headquarters Java knowledge The Java programming language is one of the glorious tools that make pro- gramming Android a breeze compared with programming for other mobile platforms. Whereas other languages insist that you manage memory, deal- locate and allocate bytes, and then shift bits around like a game of dominoes, Java has a little buddy called the Java Virtual Machine (JVM) that helps take care of that for you. The JVM allows you to focus on writing code to solve a business problem by using a clean, understandable programming language (or to build that next really cool first-person shooter game you’ve been dreaming of) instead of focusing on the plumbing just to get the screens to show up. You’re expected to understand the basics of the Java programming language before you write your first Android application. If you’re feeling a bit rusty and need a refresher course on Java, you can visit the Java tutorials site at http://java.sun.com/docs/books/tutorial. I cover some Java in this book, but you may want to spend some time with a good book like Java All-in-One For Dummies, by Doug Lowe (Wiley), if you don’t have any Java experience. Tuning Up Your Hardware You can develop Android applications on various operating systems, includ- ing Windows, Linux, and Mac OS X. I do the development in this book on a Windows 7 operating system, but you can develop using Mac OS X or Linux instead. Operating system Android supports all the following platforms: ✓ Windows XP (32-bit), Vista (32- or 64-bit), and 7 (32- or 64-bit) ✓ Mac OS X 10.5.8 or later (x86 only) ✓ Linux (tested on Linux Ubuntu Hardy Heron) Note that 64-bit distributions must be capable of running 32-bit applications. 06_9780470770184-ch02.indd 3106_9780470770184-ch02.indd 31 11/2/10 8:51 AM11/2/10 8:51 AM 32 Part I: The Nuts and Bolts of Android Throughout the book, the examples use Windows 7 64-Bit Edition. Therefore, some of the screen shots may look a little different from what you see on your machine. If you’re using a Mac or Linux machine, your paths may be different. Paths in this book look similar to this: c:\path\to\file.txt If you’re on a Mac or Linux machine, however, your paths will look similar to this: /path/to/file.txt Computer hardware Before you start installing the required software, make sure that your com- puter can run it adequately. I think it’s safe to say that just about any desktop or laptop computer manufactured in the past four years will suffice. I wish I could be more exact, but I can’t; the hardware requirements for Android simply weren’t published when I wrote this book. The slowest computer that I have run Eclipse on is a laptop with a 1.6-GHz Pentium D processor with 1GB of RAM. I’ve run this same configuration under Windows XP and Windows 7, and both operating systems combined with that hardware can run and debug Eclipse applications with no problems. To ensure that you can install all the tools and frameworks you’ll need, make sure that you have enough disk space to accommodate them. The Android developer site has a list of hardware requirements, outlining how much hard drive space each component requires, at http://developer.android. com/sdk/requirements.html. To save you time, I’ve compiled my own statistics from personal use of the tools and software development kits (SDKs). I’ve found that if you have about 3GB of free hard-drive space, you can install all the tools and frameworks nec- essary to develop Android applications. Installing and Configuring Your Support Tools Now it’s starting to get exciting. It’s time to get this Android going, but before you can do so, you need to install and configure a few tools, including SDKs: 06_9780470770184-ch02.indd 3206_9780470770184-ch02.indd 32 11/2/10 8:51 AM11/2/10 8:51 AM 33 Chapter 2: Prepping Your Development Headquarters ✓ Java JDK: Lays the foundation for the Android SDK. ✓ Android SDK: Provides access to Android libraries and allows you to develop for Android. ✓ Eclipse IDE (integrated development environment): Brings together Java, the Android SDK, and the Android ADT (Android Development Tools), and provides tools for you to write your Android programs. ✓ Android ADT: Does a lot of the grunt work for you, such as creating the files and structure required for an Android app. In the following sections, I show you how to acquire and install all these tools. A benefit of working with open-source software is that most of the time, you can get the tools to develop the software for free. Android is no exception to that rule. All the tools that you need to develop rich Android applications are free of charge. Getting the Java Development Kit For some reason, the folks responsible for naming the Java SDK decided that it would be more appropriate to name it the Java Development Kit, or JDK for short. Installing the JDK can be a somewhat daunting task, but I guide you through it one step at a time. Downloading the JDK Follow these steps to install the JDK: 1. Point your browser to http://java.sun.com/javase/downloads/ index.jsp. The Java SE downloads page appears. 2. Click the JDK link under the Java Platform (JDK) heading (see Figure 2-5). This link is on the http://java.sun.com/javase/downloads/ index.jsp page at this writing. If you’re on a Mac, install the JDK through Software Update panel. 06_9780470770184-ch02.indd 3306_9780470770184-ch02.indd 33 11/2/10 8:51 AM11/2/10 8:51 AM 34 Part I: The Nuts and Bolts of Android A new Java SE downloads page appears, asking you to specify which plat- form (Windows, Linux, or Mac) you’ll be using for your development work. Figure 2-5: Select JDK. Choose JDK. 3. Using the Platform drop-down list, confirm your platform, and then click the Download button. An optional Log in for Download screen appears. 4. Click the Skip This Step link at the bottom of the page. 5. Click JDK-6u20-windows-i586.exe to download the file. Windows opens a message box with a security warning, as shown in Figure 2-6. 6. In the Save As dialog box, select the location where you want to save the file, and click Save. Figure 2-6: The security warning. 06_9780470770184-ch02.indd 3406_9780470770184-ch02.indd 34 11/2/10 8:51 AM11/2/10 8:51 AM 35 Chapter 2: Prepping Your Development Headquarters The Web page shown in Figure 2-5 may look different in the future. To ensure that you’re visiting the correct page, visit the Android SDK System Requirements page in the online Android documentation for a direct link to the Java SDK download page. View the requirements page at http:// developer.android.com/sdk/requirements.html. You must remember what version of the Java SDK you need to install. At this writing, Android 2.2 supports Java SDK versions 5 and 6. If you install the wrong version of Java, you’ll get unexpected results during development. Installing the JDK When the download is complete, double-click the file to install the JDK. You are prompted by a dialog box that asks whether you want to allow the pro- gram to make changes to your computer. Click the Yes button. If you click the No button, the installation is stopped. When you’re prompted to do so, read and accept the license agreement. That’s all there is to it! You have the JDK installed and are ready to move to the next phase. In this section, I show you how to install the Android SDK step by step. Acquiring the Android SDK The Android SDK is composed of a debugger, Android libraries, a device emulator, documentation, sample code, and tutorials. You can’t develop Android apps without it. Downloading the Android SDK To download the Android SDK, follow these steps: 1. Point your browser to http://developer.android.com/sdk/ index.html. 2. Choose the latest version of the SDK starter package for your platform. 3. Extract the SDK. I recommend extracting to c:\android because I reference this loca- tion later in this chapter. You’ve just downloaded the Android SDK. 06_9780470770184-ch02.indd 3506_9780470770184-ch02.indd 35 11/2/10 8:51 AM11/2/10 8:51 AM 36 Part I: The Nuts and Bolts of Android 4. Navigate to the directory where you extracted the SDK, and double- click SDK Setup, as shown in Figure 2-7. Figure 2-7: Double-click SDK Setup. 5. If you’re prompted to accept the authenticity of the file, click Yes. The Android SDK and AVD Manager dialog box opens. 6. Select the SDK Platform Android 2.2 check box. For the purposes of this book, select version 2.2, as shown in Figure 2-8. At this writing, 2.2 is the latest and greatest version of Android. You should also check the boxes for the documentation and samples that correspond with Android version 2.2 (API 8). Figure 2-8: Choose packages to install. Every time a new version of the Android OS is released, Google also releases an SDK that contains access to the added functionality in that version. If you want to include Bluetooth functionality in your app, for example, make sure that you have Android SDK version 2.0 or later, because this functionality isn’t available in earlier versions. 06_9780470770184-ch02.indd 3606_9780470770184-ch02.indd 36 11/2/10 8:51 AM11/2/10 8:51 AM 37 Chapter 2: Prepping Your Development Headquarters 7. Click Install Selected. The Choose Packages to Install dialog box opens. 8. Select the Accept radio button to accept the license and then click Install (see Figure 2-9). Figure 2-9: The Choose Packages to Install dialog box. 9. In the next dialog box, select Accept and click Install. The Installing Archives dialog box opens, displaying a progress bar (see Figure 2-10). Figure 2-10: The Installing Archives dialog box. 10. When the archives installation is complete, click the Close button. While the Android SDK is attempting to connect to the servers to obtain the files, you may occasionally receive a Failure to fetch URL error. If this happens to you, navigate to Settings, select Force https://... Sources to be Fetched Using http://, and then attempt to download the available packages again. 06_9780470770184-ch02.indd 3706_9780470770184-ch02.indd 37 11/2/10 8:51 AM11/2/10 8:51 AM 38 Part I: The Nuts and Bolts of Android Following and setting your tools path This step is optional, but I highly recommend setting the tools path because it saves you from having to remember and type the full path when you’re accessing the Android Debug Bridge (adb) via the command line. The adb lets you manage the state of an emulator or Android device so that you can debug your application or interact with the device at a high level. The adb tool is very in-depth, so I don’t go into a lot of detail about it here; for detailed information, see the Android documentation. To add the Android tools to your system-path variable, follow these steps: 1. Open Control Panel, and double-click the System icon to open System Preferences. 2. Click the Advanced System Settings link (see Figure 2-11) to open the System Properties window. Figure 2-11: The Advanced System Settings link. 3. Click the Environment Variables button (see Figure 2-12) to bring up the Environment Variables dialog box. Adding the Android NDK The Android Native Development Kit (NDK) is a set of tools that allows you to embed compo- nents that use native code — code that you’ve written in a native language such as C or C++. If you decide to take on the NDK, you still have to download the SDK. The NDK isn’t a replace- ment for the SDK; it’s an added functionality set that complements the SDK. 06_9780470770184-ch02.indd 3806_9780470770184-ch02.indd 38 11/2/10 8:51 AM11/2/10 8:51 AM 39 Chapter 2: Prepping Your Development Headquarters Figure 2-12: Click the Environment Variables button. 4. Click the New button (see Figure 2-13). Figure 2-13: The Environment Variables window. 5. In the Variable Name field, type ANDROID. 6. Type the full path to the tools directory (c:\android\android-sdk- windows\tools) in the Variable Value field (see Figure 2-14). 06_9780470770184-ch02.indd 3906_9780470770184-ch02.indd 39 11/2/10 8:51 AM11/2/10 8:51 AM D o wnload from Wow! eBook 40 Part I: The Nuts and Bolts of Android Figure 2-14: Setting up a new environment variable. 7. Click OK. 8. In the System Variables window of the resulting dialog box (see Figure 2-15), select the PATH variable. Figure 2-15: Editing the PATH variable. 9. Click Edit and then type the following text at the end of the Variable Value field: ;%ANDROID% That’s it; you’re done. Now any time you access the Android tools directory, just use your newly created system variable. In most operating systems, your system PATH variable won’t be updated until you log out of and log back on to your operating system. If you find that your PATH variable values aren’t present, try logging out of and logging back on to your computer. 06_9780470770184-ch02.indd 4006_9780470770184-ch02.indd 40 11/2/10 8:51 AM11/2/10 8:51 AM 41 Chapter 2: Prepping Your Development Headquarters Getting the Total Eclipse Now that you have the SDK, you need an integrated development environ- ment (IDE) to use it. It’s time to download Eclipse! Choosing the right Eclipse version Downloading the correct version of Eclipse is very important. At this writ- ing, Android doesn’t support Eclipse Helios (version 3.6). Check the Android System Requirements page at http://developer.android.com/sdk/ requirements.html. If you’re still unsure, download Eclipse Galileo (ver- sion 3.5). When you download the file, you’ll probably need to find the Older Versions link on the download page and select the latest Galileo version. To download the correct version, navigate to the Eclipse downloads page (www.eclipse.org/downloads); select the Older Versions link; and then select Eclipse IDE for Java Developers. Eclipse IDE for JAVA EE Developers works as well. Installing Eclipse Eclipse is a self-contained executable file; after you unzip it, the program is installed. Even though you could stop here, it’s best to pin a shortcut to your Start menu so that Eclipse is easy to find when you need it. To install Eclipse, you need to extract the contents of the Eclipse .zip file to the location of your choice. For this example, I’ll be using C:\Program Files\Eclipse. To install Eclipse, follow these steps: 1. Double-click the shortcut that you just created to run Eclipse. If you’re running a recent version of Windows, the first time you run Eclipse, a Security Warning dialog box may appear, as shown in Figure 2-16. This dialog box tells you that the publisher has not been verified and asks whether you still want to run the software. Clear the Always Ask Before Opening This File check box, and click the Run button. 06_9780470770184-ch02.indd 4106_9780470770184-ch02.indd 41 11/2/10 8:51 AM11/2/10 8:51 AM 42 Part I: The Nuts and Bolts of Android Figure 2-16: The Windows security warning. 2. Set your workspace. When Eclipse starts, the first thing you see is the Workspace Launcher dialog box, as shown in Figure 2-17. Here, you can modify your work- space if you want, but for this book, I’m sticking with the default: c:\users\\workspace Leave the Use This as the Default and Do Not Ask Again check box dese- lected, and click the OK button. Figure 2-17: Set your workspace. If you plan to develop multiple applications, I recommend using a sepa- rate workspace for each project. If you store multiple projects in one workspace, it gets difficult to keep things organized, and it’s easy to change a similarly named file in a different project. Keeping projects in their own workspaces makes it easier to find the project when you have to go back to it to fix bugs. When Eclipse finishes loading, you see the Eclipse welcome screen, shown in Figure 2-18. 06_9780470770184-ch02.indd 4206_9780470770184-ch02.indd 42 11/2/10 8:51 AM11/2/10 8:51 AM 43 Chapter 2: Prepping Your Development Headquarters Figure 2-18: The Eclipse welcome screen. Click the arrow to go to the workbench. 3. Click the curved-arrow icon on the right side of the screen to go to the workbench. Eclipse is installed and easily accessible. I show you how to add the Android Development Tools in the next section. Configuring Eclipse Android Development Tools (ADT) adds functionality to Eclipse to do a lot of the work for you. The ADT allows you to create new Android projects easily; it creates all the necessary base files so that you can start coding your appli- cation quickly. It also allows you to debug your application using the Android SDK tools. Finally, it allows you to export a signed application file, known as an Android Package (APK), right from Eclipse, eliminating the need for some command-line tools. In the beginning, I had to use various command-line utilities to build an APK. Although that wasn’t hard, it was tedious and some- times frustrating. The ADT eliminates this frustrating process by guiding you through it “wizard style” from within Eclipse. I show you how to export a signed APK in Chapter 8. 06_9780470770184-ch02.indd 4306_9780470770184-ch02.indd 43 11/2/10 8:51 AM11/2/10 8:51 AM 44 Part I: The Nuts and Bolts of Android Setting up Eclipse with the ADT To set up Eclipse with the ADT, follow these steps: 1. Start Eclipse, if it’s not already running. 2. Choose Help➪Install New Software. The Install window pops up (see Figure 2-19). This window allows you to install new plug-ins in Eclipse. 3. Click the Add button to add a new site that will display the Add Repository window (see Figure 2-20). Sites are the Web addresses where the software is hosted on the Internet. Adding a site to Eclipse makes it easier for you to update the software when a new version is released. Figure 2-19: Click the Add button to add a new site. 4. Type a name in the Name field. I recommend using Android ADT, but it can be anything you choose. 5. Type https://dl-ssl.google.com/android/eclipse/ in the Location field. 06_9780470770184-ch02.indd 4406_9780470770184-ch02.indd 44 11/2/10 8:51 AM11/2/10 8:51 AM 45 Chapter 2: Prepping Your Development Headquarters Figure 2-20: Enter the name and location of the site. 6. Click the OK button. Android ADT is selected in the Work With drop-down menu, and the available options are displayed in the Name and Version window of the Install Details dialog box. 7. In the Install dialog box, select the check box next to Developer Tools, and click the Next button (see Figure 2-21). Figure 2-21: Select Developer Tools. The Install Details dialog box should list both the Android Dalvik Debug Monitor Server (DDMS; see “Get physical with a real Android device,” later in this chapter) and the ADT (see Figure 2-22). 06_9780470770184-ch02.indd 4506_9780470770184-ch02.indd 45 11/2/10 8:51 AM11/2/10 8:51 AM 46 Part I: The Nuts and Bolts of Android Figure 2-22: DDMS and ADT listed in the Install Details dia- log box. 8. Click the Next button to review the software licenses. 9. Click the Finish button. 10. When you’re prompted to do so, click the Restart Now button to restart Eclipse. The ADT plug-in is installed. Setting the location of the SDK In this section, I guide you through the configuration process. I know that this seems like a lot to do, but you’re almost done, and you have to do this work only once. Follow these steps: 1. Choose Window➪Preferences. The Preferences dialog box opens (see Figure 2-23). 2. Select Android in the left pane. 3. Set the SDK Location to C:\android\android-sdk-windows. 4. Click OK. 06_9780470770184-ch02.indd 4606_9780470770184-ch02.indd 46 11/2/10 8:51 AM11/2/10 8:51 AM 47 Chapter 2: Prepping Your Development Headquarters Figure 2-23: Specify the loca- tion of the SDK in the Preferences dialog box. Eclipse is configured, and you’re ready to start developing Android apps. If you’re having difficulty downloading the tools from https://dl-ssl. google.com/android/eclipse, try removing the s from https://, as fol- lows: http://dl-ssl.google.com/android/eclipse. Getting Acquainted with the Android Development Tools Now that the tools of the trade are installed, I introduce you to the SDK and some of the tools that are included with it. Navigating the Android SDK Whoa! You find a lot of folders in the SDK! Don’t worry; the folder structure of the Android SDK is pretty easy to understand when you get the hang of it. You need to understand the structure of the SDK for you to fully master it. Table 2-1 outlines what each folder is and what it contains. 06_9780470770184-ch02.indd 4706_9780470770184-ch02.indd 47 11/2/10 8:51 AM11/2/10 8:51 AM 48 Part I: The Nuts and Bolts of Android Table 2-1 Folders in the Android SDK SDK Folder Description usb_driver Contains the drivers for Android devices. If you connect your Android device to the computer, you need to install this driver so that you can view, debug, and push appli- cations to your phone via the ADT. The usb_driver folder won’t be visible until you install the USB driver. tools Contains various tools that are available for use during development — debugging tools, view-management tools, and build tools, to name a few. temp Provides a temporary swap for the SDK. At times, the SDK may need a temporary space to perform some work. This folder is where that work takes place. samples Contains a bunch of sample projects for you to play with. Full source code is included. platforms Contains the platforms that you target when you build Android applications, such as folders named android-8 (which is Android 2.2), android-4 (which is Android 1.6), and so on. docs Contains a local copy of the Android SDK documentation. add-ons Contains additional APIs that provide extra functionality. This folder is where the Google APIs reside; these APIs include mapping functionality. This folder remains empty until you install any of the Google Maps APIs. Targeting Android platforms Android platform is just a fancy way of saying Android version. At this writing, seven versions of Android are available, ranging from version 1.1 through version 2.2. You can target any platform that you choose. Keep in mind that several versions of Android are still widely used on phones. If you want to reach the largest number of users, I suggest targeting an earlier version. If your app requires functionality that older platforms can’t support, however, by all means target the new platform. It wouldn’t make any sense to write a Bluetooth toggle widget targeting any platform earlier than 2.0 because earlier platforms can’t use Bluetooth. Figure 2-24 shows the percentage of each platform in use as of July 1, 2010. To view the current platform statistics, visit http://developer.android. com/resources/dashboard/platform-versions.html. 06_9780470770184-ch02.indd 4806_9780470770184-ch02.indd 48 11/2/10 8:51 AM11/2/10 8:51 AM 49 Chapter 2: Prepping Your Development Headquarters Figure 2-24: Android distribution as of July 1, 2010. Android 2.1 Android 1.6 Android 2.2 Android 1.5 Other Using SDK tools for everyday development You just installed the SDK tools. Now I introduce you to these tools so that they can work for you. The SDK tools are what you use to develop your Android apps. They allow you to develop applications easily as well as give you the ability to debug them. New features packed into every release enable you to develop for the latest version of Android. Say hello to my little emulator The emulator has to be my favorite tool of all. Not only does Google provide the tools you need to develop apps, but it also gives you this awesome little emulator that allows you to test your app! The emulator does have some limitations, however — it cannot emulate certain hardware components such as the accelerometer, but not to worry. Plenty of apps can be developed and tested using only an emulator. When you’re developing an app that uses Bluetooth, for example, you should use an actual device that has Bluetooth. If you develop on a speedy com- puter, testing on an emulator is fast, but on slower machines, the emulator can take a long time to do a seemingly simple task. When I develop on an older machine, I usually use an actual device, but when I use my newer, faster machine, I typically use the emulator because I don’t notice much lag, if any. The emulator comes in handy for testing your app at different screen sizes and resolutions. It’s not always practical or possible to have several devices connected to your computer at the same time, but you can run multiple emu- lators with varying screen sizes and resolutions. 06_9780470770184-ch02.indd 4906_9780470770184-ch02.indd 49 11/2/10 8:51 AM11/2/10 8:51 AM 50 Part I: The Nuts and Bolts of Android Get physical with a real Android device The emulator is awesome, but sometimes you need an actual device to test on. The DDMS allows you to debug your app on an actual device, which comes in handy for developing apps that use hardware features that aren’t or can’t be emulated. Suppose that you’re developing an app that tracks the user’s location. You can send coordinates to the device manually, but at some point in your development, you probably want to test the app and find out whether it in fact displays the correct location. Using an actual device is the only way to do this. If you develop on a Windows machine and want to test your app on a real device, you need to install a driver. If you’re on a Mac or Linux machine, you can skip this section, because you don’t need to install the USB driver. To download the Windows USB driver for Android devices, follow these steps: 1. In Eclipse, choose Window➪Android SDK and AVD Manager. The Android SDK and AVD Manager dialog box opens (see Figure 2-25). 2. In the left pane, select Available Packages. 3. Expand the Android repository, and select the USB Driver package. Figure 2-25: The available packages. 4. Click the Install Selected button. The Choose Packages to Install dialog box opens. 5. Select the Accept radio button to accept the license and then click the Install button (see Figure 2-26). The Installing Archives dialog box opens, displaying a progress bar. 06_9780470770184-ch02.indd 5006_9780470770184-ch02.indd 50 11/2/10 8:51 AM11/2/10 8:51 AM 51 Chapter 2: Prepping Your Development Headquarters Figure 2-26: Click the Install button. 6. When the package finishes downloading and installing, click the Close button. 7. Exit the Android SDK and AVD Manager dialog box. Debug your work The DDMS equips you with the tools you need to find those pesky bugs, allowing you to go behind the scenes as your app is running to see the state of hardware such as wireless radios. But wait. There’s more! It also simu- lates actions that you normally need an actual device to do, such as sending Global Positioning System (GPS) coordinates manually, simulating a phone call, or simulating a text message. I recommend getting all the DDMS details at http://developer.android.com/guide/developing/tools/ ddms.html. Try out the API and SDK samples The API and SDK samples are provided to demonstrate how to use the func- tionality provided by the API and SDK. If you ever get stuck and can’t figure out how to make something work, you should visit http://developer. android.com/resources/samples/index.html. Here, you can find samples of almost anything from using Bluetooth to making a two-way text application or a 2D game. You also have a few samples in your Android SDK. Simply open the Android SDK and navigate to the samples directory, which contains various samples that range from interacting with services to manipulating local databases. You should spend some time playing with the samples. I’ve found that the best way to learn Android is to look at existing working code bases and then play with them in Eclipse. 06_9780470770184-ch02.indd 5106_9780470770184-ch02.indd 51 11/2/10 8:51 AM11/2/10 8:51 AM 52 Part I: The Nuts and Bolts of Android Give the API demos a spin The API demos inside the samples folder in the SDK are a collection of apps that demonstrate how to use the included APIs. Here, you can find sample apps with a ton of examples, such as these: ✓ Notifications ✓ Alarms ✓ Intents ✓ Menus ✓ Search ✓ Preferences ✓ Background services If you get stuck or just want to prep yourself for writing your next spectacular Android application, check out the complete details at http://developer. android.com/resources/samples/ApiDemos/index.html. 06_9780470770184-ch02.indd 5206_9780470770184-ch02.indd 52 11/2/10 8:51 AM11/2/10 8:51 AM Part II Building and Publishing Your First Android Application 07_9780470770184-pp02.indd 5307_9780470770184-pp02.indd 53 11/2/10 8:52 AM11/2/10 8:52 AM In this part . . . In Part II, I walk you through developing a useful Android application. I start with the basics of the Android tools and then delve into developing the screens and home- screen widgets that users will interact with. When the application is complete, I demonstrate how to sign your application digitally so that you can deploy it to the Android Market. I finish the part with an in-depth view of publishing your application to the Android Market. 07_9780470770184-pp02.indd 5407_9780470770184-pp02.indd 54 11/2/10 8:52 AM11/2/10 8:52 AM Chapter 3 Your First Android Project In This Chapter ▶ Creating a new blank project in Eclipse ▶ Understanding errors ▶ Creating an emulator ▶ Setting up and copying launch configurations ▶ Running your first app ▶ Studying the anatomy of a project You’re excited to get started building the next best Android application known to man, right? Good! But before you create that next blockbuster application, I’m going to walk you through how to create your first Android application to help solidify a few key aspects in the Android project creation process. You will be creating a very simple “Hello Android” application that requires no coding whatsoever. What? No coding? How’s that possible? Follow along; I’ll show you. Starting a New Project in Eclipse First things first: You need to start Eclipse. After it’s started, you should see something that looks similar to Figure 3-1. Now you’re ready to start cooking with Android. Remember setting up your development environment in the previous chap- ter? I’m sure you do! In that chapter, you set up all the tools and frameworks necessary to develop Android applications, and in the process of doing so, the Eclipse Android Development Tools (ADT) plug-in was installed. The ADT plug-in gives you the power to generate new Android applications directly from within the Eclipse File menu. That’s exactly what you’re about to do; I think you’re ready to create your first Android Application project. Follow these steps: 08_9780470770184-ch03.indd 5508_9780470770184-ch03.indd 55 11/2/10 8:54 AM11/2/10 8:54 AM 56 Part II: Building and Publishing Your First Android Application Figure 3-1: The Eclipse development environment has been opened. 1. In Eclipse, choose File➪New➪Project. The New Project/Select a Wizard dialog box opens, as shown in Figure 3-2. Figure 3-2: The New Project/ Select a Wizard dialog box. 08_9780470770184-ch03.indd 5608_9780470770184-ch03.indd 56 11/2/10 8:54 AM11/2/10 8:54 AM D o wnload from Wow! eBook 57 Chapter 3: Your First Android Project 2. From the New Project/Select a Wizard dialog box, expand the Android item by clicking the Android folder. 3. After the Android folder is expanded, click Android Project and then click the Next button. The New Android Project dialog box appears, as shown in Figure 3-3. 4. In the Project Name field, type Hello Android. The Project Name field is very important, the descriptive name that you provide identifies your project in the Eclipse workspace. After your proj- ect is created, a folder in the workspace is named with the project name you define here. 5. In the Contents panel, leave the default radio button Create New Project in Workspace and the check box Use Default Location selected. These defaults are selected automatically when a new project is cre- ated. The Contents panel identifies where the contents of your Eclipse projects are going to be stored in the file system. The contents are the source files that make up your Android project. Figure 3-3: The New Android Project dialog box. 08_9780470770184-ch03.indd 5708_9780470770184-ch03.indd 57 11/2/10 8:54 AM11/2/10 8:54 AM 58 Part II: Building and Publishing Your First Android Application When you set up Eclipse in Chapter 2, the Eclipse system asked you to set your default workspace. The workspace usually defaults to your home directory. A home directory is where the system places files perti- nent to you. Figure 3-4 shows my home directory. If you would rather store your files in a location other than the default workspace location, deselect the Use Default Location check box. This enables the Location text box. Click the Browse button, and select a location where you’d like your files to be stored. 6. In the Build Target section, select Android 2.2. The Build Target section identifies which application programming interface (API) you want to develop under for this project. By selecting Android 2.2, you have elected to use the Android 2.2 framework. Doing so allows you to develop with the Android 2.2 APIs, which include new features such as the Backup Manager and new speech-recognition APIs. If you selected Android 1.6 as the target, you would not be able to use any features supported by version 2.2 (or 2.1). Only the features in the targeted framework are supported. If you installed other software devel- opment kits (SDKs) in Chapter 2, you might have the option of selecting them at this point. If you selected version 1.6, you’d have access only to version 1.6 APIs. Figure 3-4: My default workspace location for the Hello Android project is C:/ Users/ dfelker/ work space. 08_9780470770184-ch03.indd 5808_9780470770184-ch03.indd 58 11/2/10 8:54 AM11/2/10 8:54 AM 59 Chapter 3: Your First Android Project For more information, see the section “Understanding the Build Target and Min SDK Version settings,” later in this chapter. 7. In the Properties section, type Hello Android in the Application Name box. The application name is the name of the application as it pertains to Android. When the application is installed on the emulator or physical device, this name will appear in the application launcher. 8. In the Package Name box, type com.dummies.android.helloandroid. This is the name of the Java package (see the nearby sidebar “Java pack- age nomenclature”). 9. In the Create Activity box, type MainActivity. The Create Activity section defines what the initial activity will be called. This is the entry point to your application. When Android runs your application, this is the first file that gets accessed. A common naming pattern for the first activity in your application is MainActivity.java (how creative, right?). 10. In the Min SDK Version box, type 8. Your screen should now look similar to Figure 3-5. Java package nomenclature A package in Java is a way to organize Java classes into namespaces similar to modules. Each package must have a unique name for the classes it contains. Classes in the same package can access one another’s package-access members. Java packages have a naming convention defined as the hierarchical naming pattern. Each level of the hierarchy is separated by periods. A package name starts with the highest-level domain name of the organization; then the subdomains are listed in reverse order. At the end of the package name, the company can choose what it would like to call the package. The package name com. dummies.android.helloandroid is the name you will use for this example. Notice that the highest-level domain is at the front of the package name (com). Subsequent subdomains are separated by periods. The package name traverses down through the subdomains to get to the final package name of helloandroid. A great example of another use for a pack- age would be having a Java package for all your Web-related communications. Any time you needed to find one of your Web-related Java classes, you could open that Java pack- age and work on your Web-related Java classes. Packages allow you to keep your code organized. 08_9780470770184-ch03.indd 5908_9780470770184-ch03.indd 59 11/2/10 8:54 AM11/2/10 8:54 AM 60 Part II: Building and Publishing Your First Android Application Understanding Android versioning Version codes are not the same as version names. Huh? Android has version names and version codes. Each version name has one and only one version code associated with it. The following table outlines the version names and their respective version code. Version Name (Platform Level) Version Code (API Level) 1.5 3 1.6 4 2.0 5 2.0.1 6 2.1 7 2.2 8 You can also find this information in the Build Target section of the New Android Project dialog box. Figure 3-5: A completed New Android Project wizard. 08_9780470770184-ch03.indd 6008_9780470770184-ch03.indd 60 11/2/10 8:54 AM11/2/10 8:54 AM 61 Chapter 3: Your First Android Project The Min SDK Version defines the minimum version code of Android that the user must have before he can run your application. Note that this field is not required to create your app. For more information, see the section “Understanding the Build Target and Min SDK Version settings,” later in this chapter. 11. Click the Finish button. You’re done! You should see Eclipse with a single project in the Package Explorer, as shown in Figure 3-6. Figure 3-6: The Eclipse development environment with your first Android project, Hello Android. Deconstructing Your Project The Android project generated by Eclipse is a fresh clean project with no compiled binary sources. Sometimes, it takes a second for Eclipse to catch up to how fast you are, so you may notice little oddities about the system. You also need to understand what happens under the hood of Eclipse at a high level; I cover this information in the next sections. 08_9780470770184-ch03.indd 6108_9780470770184-ch03.indd 61 11/2/10 8:54 AM11/2/10 8:54 AM 62 Part II: Building and Publishing Your First Android Application Responding to error messages If you were quick enough to look (or if your computer runs on the slower edge of the spectrum), you may have noticed a little red icon that hovered over the Hello Android folder icon in the Package Explorer in your Eclipse window right after you clicked the Finish button. If you didn’t see it, you can see an example in Figure 3-7. That icon is Eclipse’s way of letting you know that something is wrong with the project in the workspace. Figure 3-7: A project with errors in Eclipse. A project with errors in Eclipse By default, Eclipse is set up to let you know when an error is found within a project with this visual queue. How can you have an error with this project? You just created the project through the New Android Project wizard; what gives? Behind the scenes, Eclipse and the Android Development Tools are doing a few things for you: ✓ Providing workspace feedback: This feedback lets you know when a problem exists with any of the projects in the workspace. You receive notification in Eclipse via icon overlays, such as the one shown in Figure 3-7. Another icon overlay you may see often is a small yellow warning icon, which alerts you to some warnings in the contents of the project. ✓ Automatically compiling: By default, Eclipse autocompiles the applica- tions in your workspace when any files within them are saved after a change. If you don’t want automatic recompilation turned on, you can turn it off by choosing Project➪Build Automatically. This disables the automatic building of the project. If this option is deselected, you need to build your project manu- ally by pressing Ctrl+B each time you change your source code. So why are you getting an error with the first build? When the project was added to your workspace, Eclipse took over, and in conjunction with the ADT, it determined that the project in the workspace had an error. The issue that raised the error in Eclipse was that the gen folder and all its con- tents were not present. (I cover the gen folder in “Understanding Project Structure,” later in this chapter.) 08_9780470770184-ch03.indd 6208_9780470770184-ch03.indd 62 11/2/10 8:54 AM11/2/10 8:54 AM 63 Chapter 3: Your First Android Project The gen folder is automatically generated by Eclipse and the ADT when the compilation takes place. As soon as the New Android Project wizard was completed, a new project was created and saved in Eclipse’s work- space. Eclipse recognized this fact and said, “Hey! I see some new files in my workspace. I need to report any errors I find as well as compile the proj- ect.” Eclipse reported the errors by placing an error icon over the folder. Immediately thereafter, the compilation step took place. During the compila- tion step, the gen folder was created by Eclipse, and the project was success- fully built. Then Eclipse recognized that the project did not have any more errors. At that time, it removed the error icon from the folder, leaving you with a clean workspace and a clean folder icon, as shown in Figure 3-8. Figure 3-8: A project in the Package Explorer that has no errors. Notice the folder icon; it has no error icon overlay on it. A project without any errors Understanding the Build Target and Min SDK Version settings So how does the Build Target setting differ from the Min SDK Version setting? The build target is the operating system you’re going to write code with. If you choose 2.2, you can write code with all the APIs in version 2.2. If you choose 1.6, you can write code only with the APIs that are in version 1.6. You can’t use the Bluetooth APIs in version 1.6, for example, because they weren’t introduced until version 2.0. If you’re targeting 2.2, you can write with the Bluetooth APIs. Know which version you want to target before you start writing your Android application. Identify which Android features you need to use to ensure that your app will function as you expect. If you’re positive that you’re going to need Bluetooth support, you need to target at least version 2.0. If you’re not sure which versions support the features you’re looking for, you can find that information on the platform-specific pages in the SDK section of http:// d.android.com. The Android 2.2 platform page is at http://d.android. com/sdk/android-2.2.html. 08_9780470770184-ch03.indd 6308_9780470770184-ch03.indd 63 11/2/10 8:54 AM11/2/10 8:54 AM 64 Part II: Building and Publishing Your First Android Application Android operating-system (OS) versions are backward-compatible. If you target Android version 1.6, for example, your application can run on Android 2.2, 2.1, 2.0, and of course 1.6. The benefit of targeting the 1.6 framework is that your application is exposed to a much larger market share. Your app can be installed on 1.6, 2.0, 2.1, and 2.2 devices (and future versions, assum- ing that no breaking framework changes are introduced in future Android OS releases). Selecting an older version doesn’t come without consequences, however. By targeting an older framework, you’re limiting the functionality that you have access to. By targeting 1.6, for example, you won’t have access to the Bluetooth APIs. The Min SDK Version setting is the minimum version of Android that the user must be running for the application to run properly on his or her device. This field isn’t required to build an app, but I highly recommend that you fill it in. If you don’t indicate the Min SDK Version, a default value of 1 is used, indicat- ing that your application is compatible with all versions of Android. If your application is not compatible with all versions of Android (such as if it uses APIs that were introduced in version code 5 — Android 2.0), and you haven’t declared the Min SDK Version, when your app is installed on a system with an SDK version code of less than 5, your application will crash at run time when it attempts to access the unavailable APIs. As best practice, always set the Min SDK Version in your application to prevent these types of crashes. Version codes and compatibility The Min SDK Version is also used by the Android Market (which I cover in detail in Chapter 8) to help identify which applications to show you based on which version of Android you’re running. If your device is running version code 3 (Android 1.6), you would want to see the apps pertinent to your version, not version code 8 (Android 2.2) apps. The Android Market man- ages which apps to show to each user through the Min SDK Version setting. If you’re having trouble deciding which version to target, the current version distribution chart can help you decide. That chart is located here: http://developer.android.com/ resources/dashboard/platform- versions.html. A good rule of thumb is to analyze the dis- tribution chart on at://developer. android.com to determine which version will give your app the best market share. The more devices you can target, the wider the audience you will have, and the more installs you have, the better your app is doing. 08_9780470770184-ch03.indd 6408_9780470770184-ch03.indd 64 11/2/10 8:54 AM11/2/10 8:54 AM 65 Chapter 3: Your First Android Project Setting Up an Emulator Aw, shucks! I bet you thought you were about to fire up this bad boy. Well, you’re almost there. You have one final thing to cover, and then you get to see all of your setup work come to life in your Hello Android application. To see this application in a running state, you need to know how to set up an emulator through the various different launch configurations. First, you need to create an Android Virtual Device (AVD), also known as an emulator. An AVD is a virtual Android device that looks, acts, walks, and talks (well, maybe not walks and talks) just like a real Android device. AVDs can be configured to run any particular version of Android as long as the SDK for that version is downloaded and installed. It’s time to get reacquainted with your old buddy the Android SDK and AVD Manager. Follow these steps to create your first AVD: 1. To open the Android SDK and AVD Manager, click the icon on the Eclipse toolbar shown in Figure 3-9. When the Android SDK and AVD Manager is open, you should see a dialog box similar to Figure 3-10. Figure 3-9: The Android SDK and AVD Manager icon on the Eclipse toolbar. The SDK/AVD Manager Figure 3-10: The Android SDK and AVD Manager dialog box. 08_9780470770184-ch03.indd 6508_9780470770184-ch03.indd 65 11/2/10 8:54 AM11/2/10 8:54 AM 66 Part II: Building and Publishing Your First Android Application 2. Click the New button. The Create New Android Virtual Device (AVD) dialog box opens, as shown in Figure 3-11. Figure 3-11: The Create New Android Virtual Device (AVD) dialog box. 3. For this AVD, in the Name field, type 2_2_Default_HVGA. For more information on naming your AVDs, see the nearby sidebar “AVD nomenclature.” 4. In the Target box, select Android 2.2 — API Level 8. 5. In the SD Card section, leave the fields blank. You have no use for an SD Card in your application. You would use the SD Card option if you needed to save data to the SD Card. If you want to have an emulator in the future, insert the size of the SD Card in mega- bytes (MB) that you would like to have created for you. At that time, an emulated SD Card will be created and dropped in your local file system. 6. Leave the Skin option set to Default (HVGA). 7. Don’t select any new features in the Hardware section. The Hardware section outlines the hardware features your AVD should emulate. You don’t need any extra hardware configuration for your first application. 08_9780470770184-ch03.indd 6608_9780470770184-ch03.indd 66 11/2/10 8:54 AM11/2/10 8:54 AM 67 Chapter 3: Your First Android Project 8. Click the Create AVD button. The Android SDK and AVD Manager dialog box should now look like Figure 3-12. Figure 3-12: The recently created AVD in the Android SDK and AVD Manager dialog box. 9. Close the Android SDK and AVD Manager dialog box. AVD nomenclature Be careful when naming your AVDs. Android is available on many devices in the real world, such as phones, e-book readers, and netbooks. A time will come when you have to test your app on various configurations; therefore, adhering to a common nomenclature when creating your AVDs can later help you recognize which AVD is for what purpose. The nomenclature I tend to follow is the following: {TARGET_VERSION}_{SKIN}_ {SCREENSIZE}[{_Options}] In Step 3 of the example in this section, you used the name of 2_2_Default_HVGA. This AVD will have a TARGET_VERSION of Android 2.2. The version name 2.2 is transformed into 2_2. The underscores are used in place of periods to keep the name of the AVD combined. Creating an AVD name as a single combined word helps when you’re working in advanced scenarios with AVDs via the command line. The SKIN is the name of the skin of the emula- tor. Emulators can have various skins that make them look like actual devices. The default skin is provided by the Android SDK. The SCREENSIZE value is the size of the screen with regard to the Video Graphics Array (VGA) size. The default is HVGA. Other options include QVGA and WVVGA800. 08_9780470770184-ch03.indd 6708_9780470770184-ch03.indd 67 11/2/10 8:54 AM11/2/10 8:54 AM 68 Part II: Building and Publishing Your First Android Application You may receive an error message after you create your AVD. This message may say Android requires .class compatibility set to 5.0. Please fix project properties. If this happens to you, you can fix it by right-clicking the project in Eclipse and choosing Android Tools➪Fix Project Properties from the context menu. You’ve created your first Android virtual device. Congratulations! Creating Launch Configurations You’re almost at the point where you can run the application. A run configu- ration specifies the project to run, the activity to start, and the emulator or device to connect to. Whoa! That’s a lot of stuff happening real quickly. Not to worry; the ADT can help you by automating a lot of the key steps so that you can get up and running quickly. The Android ADT gives you two options for creating launch configurations: ✓ Run configuration: Used when you need to run your application on a given device. You’ll use run configurations most of the time during your Android development career. ✓ Debug configuration: Used for debugging your application while it’s running on a given device. When you first run a project as an Android application by choosing Run➪Run, the ADT automatically creates a run configuration for you. The Android Application option is visible when you choose Run➪Run. After the run con- figuration is created, it’s the default run configuration, used each time you choose Run➪Run menu from then on. Creating a debug configuration You shouldn’t worry about debugging your application at this point because you’ll be debugging it in the near future. Creating a run configuration Now it’s your turn to create a run configuration for your application. If you’re feeling ambitious and decide that you’d like to create a run configu- ration manually, follow along here. Don’t worry; it’s very simple. Follow these steps: 08_9780470770184-ch03.indd 6808_9780470770184-ch03.indd 68 11/2/10 8:54 AM11/2/10 8:54 AM 69 Chapter 3: Your First Android Project 1. Choose Run➪Run Configurations. The Run Configurations dialog box opens, as shown in Figure 3-13. In this dialog box, you can create many types of run configurations. The left side of the dialog box lists many types of configurations, but the ones that you should pay attention to are as follows: • Android Application • Android JUnit Test Figure 3-13: The Run Configura- tions dialog box. 2. Select the Android Application item, and click the New Launch Configuration icon, shown in Figure 3-14 (or right-click Android Application and choose New from the context menu). The New Launch Configuration window opens. Figure 3-14: The New Launch Configuration icon. New launch configuration 08_9780470770184-ch03.indd 6908_9780470770184-ch03.indd 69 11/2/10 8:54 AM11/2/10 8:54 AM D o wnload from Wow! eBook 70 Part II: Building and Publishing Your First Android Application 3. Type ExampleConfiguration in the Name field. 4. On the Android tab, select the project you are creating this launch configuration for, and click the Browse button. The Project Selection dialog box opens. 5. Select Hello Android and click the OK button (see Figure 3-15). The Run Configurations dialog box reopens. Figure 3-15: Selecting the project for the new launch configuration. 6. On the Android tab, leave the Launch Action option set to Launch Default Activity. In this case, the default activity is MainActivity, which you set up in “Starting a New Project in Eclipse,” earlier in this chapter. 7. On the Target tab (see Figure 3-16), leave Automatic selected. Notice that an AVD is listed in the Select a Preferred Android Virtual Device for Deployment section. 8. Select the 2_2_Default_HVGA device. This device is the AVD that you created previously. By selecting it, you’re instructing this launch configuration to launch this AVD when a user runs the app by choosing Run➪Run. This view has both manual and automatic options. The manual option allows you to choose which device to connect to when using this launch configuration. Automatic sets a predefined AVD to use when launching in this current launch configuration. 9. Leave the rest of the settings alone, and click the Apply button. 08_9780470770184-ch03.indd 7008_9780470770184-ch03.indd 70 11/2/10 8:54 AM11/2/10 8:54 AM 71 Chapter 3: Your First Android Project Figure 3-16: A new, manually created launch configura- tion named Example Config- uration. Congratulations! You’ve created your first launch configuration by hand. Duplicating your launch configuration for quick setup At some point, during your very successful and lucrative Android develop- ment career, one of your applications may have a problem on one particular device. Launch configurations are designed to help you launch into a par- ticular environment quickly. Setting up many launch configurations can be a time-consuming task, however — especially if the launch configuration needs to be altered only slightly from an existing launch configuration. Fortunately, the ADT has included functionality that duplicates existing launch configura- tions, which allows you to quickly create various launch configurations that are set up independently with their own configuration in mind. To duplicate an existing launch configuration, follow these steps: 1. Make sure that the launch configuration window is open. If it’s not, choose Run➪Run Configurations to open the launch configura- tion window. 08_9780470770184-ch03.indd 7108_9780470770184-ch03.indd 71 11/2/10 8:54 AM11/2/10 8:54 AM 72 Part II: Building and Publishing Your First Android Application 2. In the left panel, right-click ExampleConfiguration, and choose Duplicate from the context menu. This step creates a new launch configuration that’s an exact copy of ExampleConfiguration. Its name will be ExampleConfiguration (1). 3. Change the name of the run configuration by typing DuplicateTest in the Name field near the top of the window. You have created a duplicate launch configuration, and now you can change various settings to give the launch configuration a unique configuration. You don’t need the DuplicateTest launch configuration; it was cre- ated to illustrate how to duplicate an existing launch configuration. 4. To delete this configuration, select DuplicateTest in the left panel and click the Delete button on the toolbar, or right-click it and choose Delete from the context menu. 5. Click the Close button to close the Run Configurations dialog box. Running the Hello Android App Congratulations! You’ve made it! Understanding the basics of how to get an Android application up and running has been a simple yet detailed process. You’re now ready to see your hard work in action. You’ve created a launch configuration and Android Virtual Device; now it’s time for you to get the application running. Finally! Running the app in the emulator Running the application is simple. Upon your instruction, the ADT will launch an emulator with the default launch configuration you built earlier in this chapter. Starting your application is as simple as choosing Run➪Run or pressing Ctrl+F11. Either action launches the application in an emulator using the default launch configuration — in this case, ExampleConfiguration. The ADT compiles your application and then deploys it to the emulator. If you didn’t create a launch configuration, you see the Run As dialog box, shown in Figure 3-17. Choose Android Application, and a launch configura- tion is created for you. 08_9780470770184-ch03.indd 7208_9780470770184-ch03.indd 72 11/2/10 8:54 AM11/2/10 8:54 AM 73 Chapter 3: Your First Android Project Figure 3-17: The Run As dialog box appears when a launch configura- tion hasn’t been set up for the proj- ect you’re attempting to run. If you created the ExampleConfiguration, you see the emulator loading, as shown in Figure 3-18. Figure 3-18: The initial emulator in a loading state, with the port number the emulator is running under and the AVD name in the window’s title bar. Port number AVD name Help! My emulator never loads! It stays stuck on the ANDROID screen(s)! No need to worry, comrade. The first time the emulator starts, the system could take upwards of 10 minutes for the emulator to finally finish loading. This is because you’re running a virtual Linux system in the emulator. The emulator has to boot up and initialize. The slower your computer, the slower the emula- tor will be in its boot process. 08_9780470770184-ch03.indd 7308_9780470770184-ch03.indd 73 11/2/10 8:54 AM11/2/10 8:54 AM 74 Part II: Building and Publishing Your First Android Application The emulator has many boot screens. The first is shown in Figure 3-18. The window’s title bar contains the port number that the emulator is running on your computer (5554) and the AVD name (2_2_Default_HVGA). Roughly one half of boot time is spent in this screen. The second boot screen shows the Android logo (see Figure 3-19). This logo is the same one that default Android OS users see when they boot their phones (if a device manufacturer hasn’t installed its own user-interface cus- tomizations, as on the HTC Sense). The third and final screen you see is the loaded emulator, shown in Figure 3-20. Figure 3-19: The default loading screen for the Android OS. Figure 3-20: The loaded 2_2_ Default_ HVGA emulator. 08_9780470770184-ch03.indd 7408_9780470770184-ch03.indd 74 11/2/10 8:54 AM11/2/10 8:54 AM 75 Chapter 3: Your First Android Project Save valuable time by leaving the emulator running. The emulator doesn’t have to be loaded each time you want to run your application. After the emulator is running, you can change your source code and then rerun your application. The ADT will find the running emulator and deploy your applica- tion to the emulator. When the emulator completes its loading phase, the default locked home screen appears. To unlock the home screen, click and drag the Lock icon to the right side of the screen. When the icon reaches the far side of the Android screen, release the icon. During the drag, the icon’s background turns green, and its label changes to Unlock, as shown in Figure 3-21. Figure 3-21: Unlocking a locked home screen. Click and drag to the right side of the screen. After the emulator is unlocked, the home screen appears, as shown in Figure 3-22. 08_9780470770184-ch03.indd 7508_9780470770184-ch03.indd 75 11/2/10 8:54 AM11/2/10 8:54 AM 76 Part II: Building and Publishing Your First Android Application Figure 3-22: The emulator home screen. Immediately thereafter, the ADT starts the Hello Android application for you. You should see a black screen containing the words Hello World, MainActivity!, as shown in Figure 3-23. Congratulations! You just created and started your first Android application. Figure 3-23: The Hello Android application in the emulator. If you don’t unlock the screen when the emulator starts, the ADT won’t be able to start the application. If you unlock the home screen and your applica- tion doesn’t started within five to ten seconds, simply run the application from Eclipse again by choosing Run➪Run. The application is redeployed to the device, and it starts running. You can view the status of the installation via the Console view in Eclipse, as shown in Figure 3-24. 08_9780470770184-ch03.indd 7608_9780470770184-ch03.indd 76 11/2/10 8:54 AM11/2/10 8:54 AM 77 Chapter 3: Your First Android Project Figure 3-24: The Console view in Eclipse allows you to view what’s happen- ing behind the scenes while your app is deploying to a device. The Console Checking deployment status Inside Console view, you can see information regarding the state of your application deployment. Here’s the full text of that information: [2010-07-05 13:13:46 - Hello Android] ------------------------------ [2010-07-05 13:13:46 - Hello Android] Android Launch! [2010-07-05 13:13:46 - Hello Android] adb is running normally. [2010-07-05 13:13:46 - Hello Android] Performing com.dummies.android. helloandroid.MainActivity activity launch [2010-07-05 13:13:46 - Hello Android] Automatic Target Mode: using existing emulator ‘emulator-5554’ running compatible AVD ‘2_2_Default_HVGA’ [2010-07-05 13:13:48 - Hello Android] Application already deployed. No need to reinstall. [2010-07-05 13:13:48 - Hello Android] Starting activity com.dummies.android. helloandroid.MainActivity on device [2010-07-05 13:13:49 - Hello Android] ActivityManager: Starting: Intent { act=android.intent.action.MAIN cat=[android.intent.category. LAUNCHER] cmp=com.dummies.android.helloandroid/.MainActivity } [2010-07-05 13:13:49 - Hello Android] ActivityManager: Warning: Activity not started, its current task has been brought to the front 08_9780470770184-ch03.indd 7708_9780470770184-ch03.indd 77 11/2/10 8:54 AM11/2/10 8:54 AM 78 Part II: Building and Publishing Your First Android Application The Console view provides valuable information on the state of the applica- tion deployment. It lets you know it’s launching an activity; shows what device the ADT is targeting; and shows warning information, as presented in the last line of the Console view: [2010-07-05 13:13:49 - Hello Android] ActivityManager: Warning: Activity not started, its current task has been brought to the front ADT informs you that the activity — MainActivity, in this case — hasn’t been started because it was already running. Because the activity was already running, ADT brought that task to the foreground (the Android screen) for you to see. Understanding Project Structure Congratulations again! You created your first application. You even did it without coding. It’s nice that the ADT provides you with the tools to fire up a quick application, but that’s not going to help you create your next block- buster application. The beginning of this chapter walked you through how to create a boilerplate Android application with the New Android Project wizard. From here on, you will use the file structure that the Android wizard created for you. The following sections aren’t ones that you should skim (trust me, they’re important!), because you’ll spend your entire Android development career navigating these folders. Understanding what they’re for and how they got there is a key aspect of understanding Android development. Navigating the app’s folders In Eclipse, the Package Explorer expands the Hello Android project so that it resembles Figure 3-25. After the Hello Android project is expanded, the list of subfolders includes ✓ src ✓ gen ✓ Android version (such as Android 2.2) ✓ assets ✓ res 08_9780470770184-ch03.indd 7808_9780470770184-ch03.indd 78 11/2/10 8:54 AM11/2/10 8:54 AM 79 Chapter 3: Your First Android Project Figure 3-25: The Package Explorer with the Hello Android project folder structure expanded. Package Explorer These folders aren’t the only ones that you can have inside an Android project, but they’re the default folders created by the New Android Project wizard. Other folders include bin, libs, and referenced libraries. You won’t see the bin folder initially, because it’s hidden from view in the latest version of the ADT (which may change in future versions of the ADT). The libs and referenced libraries folders don’t show up until you add a third-party library and reference it in your project. I cover this process in detail later in this chapter. The two other files in the project are AndroidManifest.xml and default. properties. The AndroidManifest.xml file helps you identify the components that build and run the application, whereas the default. properties file helps you identify the default properties of the Android project (such as Android version). I discuss all these folders and files in the following sections. 08_9780470770184-ch03.indd 7908_9780470770184-ch03.indd 79 11/2/10 8:54 AM11/2/10 8:54 AM 80 Part II: Building and Publishing Your First Android Application Source (src) folder The source folder — known as the src folder in Android projects — includes your stub MainActivity.java file, which you created in the New Android Project wizard earlier in this chapter. To inspect the contents of the src folder, you must expand it. Follow these steps: 1. Select the src folder, and click the small arrow to the left of the folder to expand it. You see your project’s default package: com.dummies.android. helloandroid. 2. Select the default package, and expand it. This step exposes the MainActivity.java file within the com. dummies.android.helloandroid package, as shown in Figure 3-26. Figure 3-26: The src folder expanded and show- ing the stub Main Activity. java file inside the default com. dummies. android. hello android Java package. You aren’t limited to a single package in your Android applications. In fact, separating different pieces of core functionality in your Java classes into packages is considered to be a best practice. An example would be if you had a class whose responsibility was to communicate with a Web API through eXtensible Markup Language (XML). Also, your application might have Customer objects that represent a customer domain model, and those cus- tomers are retrieved via the Web API classes. At this point, you might have two extra Java packages that contain the additional Java classes: 08_9780470770184-ch03.indd 8008_9780470770184-ch03.indd 80 11/2/10 8:54 AM11/2/10 8:54 AM 81 Chapter 3: Your First Android Project ✓ com.dummies.android.helloandroid.models ✓ com.dummies.android.helloandroid.http These packages would contain their respective Java components. com. dummies.android.helloandroid.models would contain the domain model Java classes, and com.dummies.android.helloandroid.http would contain the HTTP-related Java classes (Web APIs). An Android project set up this way would look similar to Figure 3-27. Figure 3-27: An example of having multiple packages under the src folder that contain their own respec- tive Java classes. New packages containing models and HTTP (Web API) components Target Android Library folder Wait a second; I skipped the gen folder! I delve into that folder when I reach the res folder. But for now, I want to focus on the Target Android Library folder. This isn’t really a folder per se, but is more along the lines of an item in Eclipse presented through the ADT. This item includes the android.jar file that your application builds against. The version of this file was determined by the build target that you chose in the New Android Project wizard. Expanding the Android 2.2 item in the project exposes the android.jar file and the path to where it’s installed, as shown in Figure 3-28. You may notice that the SDK is installed in the c:\SDK\ folder, which illus- trates the fact that you don’t have to install the SDK in any given location. It can go anywhere in your file system. 08_9780470770184-ch03.indd 8108_9780470770184-ch03.indd 81 11/2/10 8:54 AM11/2/10 8:54 AM 82 Part II: Building and Publishing Your First Android Application Figure 3-28: The Android 2.2 version of the android. jar file with its location. The android.jar file for version 2.2 Assets (assets) folder The assets folder is empty by default. This folder is used to store raw asset files. A raw asset file could be one of many assets you may need for your applica- tion to work. A great example would be a file that contains data in a propri- etary format for consumption on the device. Android has the Asset Manager, which can return all the assets currently in the assets directory. Upon read- ing an asset, your application could read the data in the file. If you were to create an application that had its own dictionary for word lookups (for auto- complete, perhaps), you may want to bundle the dictionary into the project by placing the dictionary file (usually, an XML or binary file such as a SQLite database) in the assets directory. Android treats assets as a raw approach to resource management. You aren’t limited in what you can place in the assets directory. Note, however, that working with assets can be a little more tedious than working with resources, because you’re required to work with streams of bytes and convert them to the objects you’re after — audio, video, text, and so on. Assets don’t receive resource IDs like resources in the res directory. You have to work with bits, bytes, and streams manually to access the contents. Resources (res) folder The res folder contains the various resources that your application can consume. You should always externalize any resources that your application needs to consume. Classic examples of such resources include strings and images. As an example, you should avoid placing strings inside your code. Instead, create a string resource and reference that resource from within code. I show you how to do this later in the book. Such resources should be grouped in the res subdirectory that suits them best. 08_9780470770184-ch03.indd 8208_9780470770184-ch03.indd 82 11/2/10 8:54 AM11/2/10 8:54 AM 83 Chapter 3: Your First Android Project You should also provide alternative resources for specific device configu- rations by grouping them in specifically named resource directories. At run time, Android determines which configuration the application is run- ning in and chooses the appropriate resource (or resource folder) to pull its resources from. You may want to provide a different user interface (UI) layout depending on the screen size or different strings depending on the language setting, for example. After you externalize your resources, you can access them in code through resource IDs that are generated by the ADT in the R class (see “The mysteri- ous gen folder,” later in this chapter. You should place each resource in a specific subdirectory of your project’s res directory. The subdirectories listed in Table 3-1 are the most common types of resource folders under the parent res directory. Table 3-1 Supported Subdirectories of the res Directory Directory Resource Type anim/ XML files that define animations. color/ XML files that define a list of colors. drawable/ Bitmap files (.png, .9.png, .jpg, .gif) or XML files that are compiled into the following drawable resources. drawable-hdpi/ Drawables for high-resolution screens. The hdpi qualifier stands for high-density screens. This is the same as the drawable/ resource folder except that all bitmap or XML files stored here are compiled into high-resolution drawable resources. drawable-ldpi/ Drawables for low-resolution screens. The ldpi qualifier stands for low-density screens. This is the same as the drawable/ resource folder except that all bitmap or XML files stored here are compiled into low-resolution drawable resources. drawable-mdpi/ Drawables for medium-resolution screens. The mdpi qualifier stands for medium-density screens. This is the same as the drawable/ resource folder except that all bitmap or XML files stored here are compiled into medium-resolution drawable resources. layout/ XML files that define a user interface layout. menu/ XML files that represent application menus. (continued) 08_9780470770184-ch03.indd 8308_9780470770184-ch03.indd 83 11/2/10 8:54 AM11/2/10 8:54 AM 84 Part II: Building and Publishing Your First Android Application Table 3-1 (continued) Directory Resource Type raw/ Arbitrary files to save in their raw form. Files in this directory aren’t compressed by the system. values/ XML files that contain simple values, such as strings, integers, and colors. Whereas XML resource files in other res/ folders define a single resource based on the XML filenames, files in the values/ direc- tory define multiple resources for various uses. There are a few filename conventions for the resources you can create in this directory: * arrays.xml for resource arrays (storing like items together such as strings or integers) * colors.xml for resources that define color values. Accessed via the R.colors class. * dimens.xml for resources that define dimen- sion values. For example, 20px equates 20 pixels. Accessed via the R.dimens class. * strings.xml for string values. Accessed via the R.strings class. * styles.xml for resources that represent styles. A style is similar to a Cascading Style Sheet in HTML. You can define many different styles and have them inherit from each other. Accessed via the R.styles class. Never save resource files directly in the res directory. If you do, a compiler error occurs. The resources that you save in the resource folders listed in Table 3-1 are known as default resources — that is, they define the default design and layout of your Android application. Different types of Android-powered devices may need different resources, however. If you have a device with a larger-than-normal screen, for example, you need to provide alternative layout resources to account for the difference. 08_9780470770184-ch03.indd 8408_9780470770184-ch03.indd 84 11/2/10 8:54 AM11/2/10 8:54 AM D o wnload from Wow! eBook 85 Chapter 3: Your First Android Project The resource/ mechanism inside Android is very powerful, and I could easily write a chapter on it alone, but I’m going to cover only the basics in this book to get you up and running. The resource/ mechanism can help with internationalization (enabling your app for different languages and countries), device size and density, and even resources for the mode that the phone may be in. If you’d like to dive into the ocean that is resources, you can find out more about them by reviewing the “Providing Resources” section in the Dev Guide of the Android documentation, located at http://d.android. com/guide/topics/resources/providing-resources.html. Bin, Libs, and Referenced Libraries folders Did I say ribs? No! I said libs, as in libraries. Though these folders aren’t shown in your Hello Android application, you should be aware of a couple of extra folders, one of which is the libs/ directory. The libs/ directory contains private libraries and isn’t created by default. If you need it, you need to create it manually by right-clicking the project in the Package Explorer and choosing Folder from the context menu. Eclipse asks you for the name of the folder and the name of the parent folder. Choose Hello Android, type libs, and click Finish. Private who? I’m not in the military; what gives? Private libraries usually are third-party libraries that perform some function for you. An example would be jTwitter, a third-party Java library for the Twitter API. If you were to use jTwitter in your Android application, the jtwitter.jar library would need to be placed in the libs directory. After a library is placed in the libs directory, you need to add it to your Java build path — the class path that’s used for building a Java project. If your project depends on another third-party or private library, Eclipse should know where to find that library, and setting the build path through Naming resources in the values directory There are a few filename conventions for the resources you can create in the values directory: ✓ arrays.xml for resource arrays (stor- ing like items, such as strings or integers, together) ✓ colors.xml for resources that define color values; accessed via the R.colors class. ✓ dimens.xml for resources that define dimension values (20px equals 20 pixels, for example); accessed via the R.dimens class. ✓ strings.xml for string values; accessed via the R.strings class. ✓ styles.xml for resources that repre- sent styles; accessed via the R.styles class. A style is similar to a cascading style sheet in HTML. You can define many styles and have them inherit from one another. 08_9780470770184-ch03.indd 8508_9780470770184-ch03.indd 85 11/2/10 8:54 AM11/2/10 8:54 AM 86 Part II: Building and Publishing Your First Android Application Eclipse does exactly that. Assuming that you added jtwitter.jar to your libs directory, you can add it to your build path easily by right-clicking the jtwitter.jar file and choosing Build Path➪Add to Build Path from the context menu. In the action of adding jTwitter to your build path, you may have noticed that the Referenced Libraries folder was created, as shown in Figure 3-29. This folder exists to let you know what libraries you have referenced in your Eclipse project. You can find out more about jTwitter at www.winterwell.com/software/ jtwitter.php. Figure 3-29: The Refer- enced Libraries folder with jtwitter. jar. I don’t use the libs directory in this book. But developers — myself included — commonly use third-party libraries in Android applications. I wanted to include this information in the book in case you need to reference a library in your own Android project. The mysterious gen folder Ah, you finally get to witness the magic that is the gen folder. When you create your Android application, before the first compilation, the gen folder doesn’t exist. Upon the first compilation, ADT generates the gen folder and its contents. The gen folder contains Java files generated by ADT. The ADT creates an R.java file (more about which in a moment). I covered the res folder before the gen folder because the gen folder contains items that are generated from the res directory. Without a proper understanding of what the res folder is and what it contains, you have no clue what the gen folder is for. But because you’re already an expert on the res folder, I’m going to dive right into the gen folder now. 08_9780470770184-ch03.indd 8608_9780470770184-ch03.indd 86 11/2/10 8:54 AM11/2/10 8:54 AM 87 Chapter 3: Your First Android Project When you write Java code in Android, you will come to a point when you need to reference the items in the res folder. You do this by using the R class. The R.java file is an index to all the resources defined in your res folder. You use this class as a shorthand way to reference resources you’ve included in your project. This is particularly useful with the code-completion features of Eclipse because you can quickly identify the proper resource through code completion. Expand the gen folder in the Hello Android project and the package name contained within the gen folder. Now open the R.java file by double-clicking it. You can see a Java class that contains nested Java classes. These nested Java classes have the same names as some of the res folders defined in the preceding res section. Under each of those subclasses, you can see mem- bers that have the same names as the resources in their respective res fold- ers (excluding their file extensions). The Hello Android project’s R.java file should look similar to the following code: /* AUTO-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 com.dummies.android.helloandroid; 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; } } Whoa, what’s all that 0x stuff? I’m happy to tell you that you don’t need to worry about it. The ADT tool generates this code for you so that you don’t have to worry about what’s happening behind the scenes. As you add resources and the project is rebuilt, ADT regenerates the R.java file. This newly generated file contains members that reference your recently added resources. 08_9780470770184-ch03.indd 8708_9780470770184-ch03.indd 87 11/2/10 8:54 AM11/2/10 8:54 AM 88 Part II: Building and Publishing Your First Android Application You should never edit the R.java file by hand. If you do, your application may not compile, and then you’re in a whole world of hurt. If you accidentally edit the R.java file and can’t undo your changes, you can delete the gen folder and build your project. At this point, ADT regenerates the R.java file for you. Viewing the application’s manifest file You keep track of everything you own and need through lists, don’t you? Well, that’s exactly what the Android manifest file does. It keeps track of everything your application needs, requests, and has to use to run. The Android manifest file is stored at the root of your project and is named AndroidManifest.xml. Every application must have an Android manifest file in its root directory. The application manifest file provides all the essential information to the Android system — information that it must have before it can run any of your application’s code. The application manifest file also provides the following: ✓ The name of your Java package for the application, which is the unique identifier for your application in the Android system as well as in the Android Market ✓ The components of the application, such as the activities and back- ground services ✓ The declaration of the permissions your application requires to run ✓ The minimum level of the Android API that the application requires The Android manifest file declares the version of your application. You must version your application. How you version your application is very similar to how the Android OS is versioned. It’s important to determine your applica- tion’s versioning strategy early in the development process, including consid- erations for future releases of your application. The versioning requirements are that each application have a version code and version name. I cover these values in the following sections. Version code The version code is an integer value that represents the version of the appli- cation code relative to other versions of your application. This value is used to help other applications determine their compatibility with your applica- tion. Also, the Android Market uses it as a basis for identifying the applica- tion internally and for handling updates. 08_9780470770184-ch03.indd 8808_9780470770184-ch03.indd 88 11/2/10 8:54 AM11/2/10 8:54 AM 89 Chapter 3: Your First Android Project You can set the version code to any integer value you like, but you should make sure that each successive release has a version code greater than the previous one. The Android system doesn’t enforce this rule; it’s a best prac- tice to follow. Typically, on your first release, you set your version code to 1. Then you monotonically increase the value in a given order with each release, whether the release is major or minor. This means that the version code doesn’t have a strong resemblance to the application release version that’s visible to the user, which is the version name (see the next section). The version code typi- cally isn’t displayed to users in applications. Upgrading your application code and releasing the app without increment- ing your version code causes different code bases of your app to be released under the same version. Consider a scenario in which you release your application with version code 1. This is your first release. A user installs your application via the Android Market and notices a bug in your application, and she lets you know. You fix the bug in the code, recompile, and release the new code base without updating the version code in the Android manifest file. At this point, the Android Market doesn’t know that anything has changed because it’s inspecting your version code in the application manifest. If the version code had changed to a value greater than 1, such as 2, the Market would recognize that an update had been made and would inform users who installed the version-code 1 app that an update is available. If you didn’t update the version code, users would never get the update to your code base, and they would be running a buggy app. No one likes that! Version name The version name is a string value that represents the release version of the application code as it should be shown to users. The value is a string that follows a common release-name nomenclature that describes the application version: .. An example of this release-name nomenclature is 2.1.4 or, without the value (4, in this case), 2.1. The Android system doesn’t use this value for any purpose other than to enable applications to display it to users. The version name may be any other type of absolute or relative version identi- fier. The Foursquare application, for example, uses a version-naming scheme that corresponds to the date. An example of the version application name is 2010-06-28, which clearly represents a date. The version name is left up to you. You should plan ahead and make sure that your versioning strategy makes sense to you and your users. 08_9780470770184-ch03.indd 8908_9780470770184-ch03.indd 89 11/2/10 8:54 AM11/2/10 8:54 AM 90 Part II: Building and Publishing Your First Android Application Permissions Assume that your application needs to access the Internet to retrieve some data. Android restricts Internet access by default. For your application to have access to the Internet, you need to ask for it. In the application manifest file, you must define which permissions your application needs to operate. Table 3-2 lists some of the most commonly requested permissions. Table 3-2 Commonly Requested Application Permissions Permission Description Internet The application needs access to the Internet. Write External Storage The application needs to write data to the Secure Digital Card (SD Card). Camera The application needs access to the camera. Access Fine Location The application needs access to the Global Positioning System (GPS) location. Read Phone State The application needs to access the state of the phone (such as ringing). Viewing the default.properties file The default.properties file is used in conjunction with ADT and Eclipse. It contains project settings such as the build target. This file is integral to the project, so don’t lose it! The default.properties file should never be edited manually. To edit the contents of the file, use the editor in Eclipse. You can access this editor by right-clicking the project name in the Package Explorer and choosing Properties from the context menu. This opens the Properties editor, shown in Figure 3-30. This editor allows you to change various properties of the project by select- ing any of the options on the left. You could select the Android property and change the path to the Android SDK, for example. 08_9780470770184-ch03.indd 9008_9780470770184-ch03.indd 90 11/2/10 8:54 AM11/2/10 8:54 AM 91 Chapter 3: Your First Android Project Figure 3-30: The Properties editor in Eclipse. 08_9780470770184-ch03.indd 9108_9780470770184-ch03.indd 91 11/2/10 8:54 AM11/2/10 8:54 AM 92 Part II: Building and Publishing Your First Android Application 08_9780470770184-ch03.indd 9208_9780470770184-ch03.indd 92 11/2/10 8:54 AM11/2/10 8:54 AM Chapter 4 Designing the User Interface In This Chapter ▶ Setting up the Silent Mode Toggle application ▶ Designing the layout ▶ Developing the user interface ▶ Adding an image and a button widget ▶ Making a launcher icon ▶ Previewing your work Congratulations! You discovered what Android is and how to build your first application. I’m happy to say that you are now getting into the fun stuff. You’re going to build a real application that you can use and publish to the Android Market. The application you’re going to build allows the user to toggle the mode of his or her phone’s ringer with a simple press of a button. This application seems simple, but it solves a real-world problem. Imagine that you’re at work and you’re about to go to a meeting. You can turn your phone volume down, all the way to silence, and then attend the meeting. You’d never be “that guy” whose phone rings during a meeting, would you? The problem is that you like your ringer loud, but not too loud. You never keep it on the loudest setting, only the second-to-loudest setting. When you leave your meeting, you remember to turn your phone ringer volume back up, but you always have to go all the way to the max volume, and then down one setting, just to make sure that you have the correct setting. While this isn’t a life-changing event, it’s kind of a nuisance having to do this each time you need to silence your phone’s ringer. It would be great if you had an application that would allow you to touch a button to turn the ringer off, and then, when you leave the meeting, you could touch the button again and the ringer would return to the last state that it was in. You’d never have to readjust your ringer again. That’s the application you’re about to build. 09_9780470770184-ch04.indd 9309_9780470770184-ch04.indd 93 11/2/10 8:54 AM11/2/10 8:54 AM 94 Part II: Building and Publishing Your First Android Application Creating the Silent Mode Toggle Application Your task at hand is to create the Silent Mode Toggle application, and because you’re already an expert on setting up new Android applications, I’m not going to walk you through it step by step. If you need a brief refresher on how to create a new Android app in Eclipse, review Chapter 3. Before you create the new application, you need to close all the files you already have open in Eclipse. You can do this by closing each file individually or by right-clicking the files and choosing Close All from the shortcut menu. After you have closed all the files, you need to close the current project (Hello Android) in which you’re working. In Eclipse, in the Package Explorer, right-click the Hello Android project and choose Close Project. By closing the project, you are telling Eclipse that you currently do not need to work with that project. This frees resources that Eclipse uses to track the project state, therefore speeding up your application. You’re now ready to create your new Silent Mode Toggle application. Create the new application by choosing File➪New Project. Choose Android Project from the list, and then click the Next button. Use Table 4-1 for your project settings. Table 4-1 Project Settings for Silent Mode Toggle Setting Value Application Name Silent Mode Toggle Project name Silent Mode Toggle Contents Leave the default selected (create new project in workspace) Build target Android 2.2 Package name com.dummies.android.silentmodetoggle Create activity MainActivity Min SDK Version 8 09_9780470770184-ch04.indd 9409_9780470770184-ch04.indd 94 11/2/10 8:54 AM11/2/10 8:54 AM 95 Chapter 4: Designing the User Interface Click the Finish button. You should now have the Silent Mode Toggle applica- tion in your Package Explorer, as shown in Figure 4-1. If you receive an error that looks similar to this — “The project cannot be built until build path errors are resolved” — you can resolve it by right clicking on the project and choosing Android Tools➪Fix Project Properties. This realigns your project with the IDE workspace. Figure 4-1: The Silent Mode Toggle application in Eclipse. Notice how you selected the build target of Android 2.2, and a Min SDK Version of 8. What you have done is told Android that your code can run on any device that is running at least a version code of 8 (Android 2.2). If you were to change this to version code 4, you would be saying that your app can run on any device running version 4 or higher. How do I know which version this app can run on? I’ve already tested it, before I wrote the book! When creating a new application, you should check to see whether it can run on older versions. Laying Out the Application Now that you have the Silent Mode Toggle application created inside Eclipse, it’s time for you to design the application’s user interface. The user interface is the part of your application where your users interact with your app. It is of prime concern to make this area of the application as snappy as possible in all regards. Your application is going to have a single button centered in the middle of the screen to toggle the silent mode. Directly above the button will be an image for visual feedback, letting the user know whether the phone is in silent or regular ringer mode. A picture is worth a thousand words, so take a look at Figures 4-2 and 4-3 to see what your application will look like. 09_9780470770184-ch04.indd 9509_9780470770184-ch04.indd 95 11/2/10 8:54 AM11/2/10 8:54 AM D o wnload from Wow! eBook 96 Part II: Building and Publishing Your First Android Application Figure 4-2: The Silent Mode Toggle application in regular ringer mode. Figure 4-3: The Silent Mode Toggle application in silent ringer mode. Using the XML layout file All layout files for your application are stored in the res/layouts directory of your Android project in Eclipse. When you created the Silent Mode Toggle application a moment ago, the Android Development Tools (ADT) created a file named main.xml in the res/layouts directory. This is the default layout file that the ADT creates for you when you create a new application. 09_9780470770184-ch04.indd 9609_9780470770184-ch04.indd 96 11/2/10 8:54 AM11/2/10 8:54 AM 97 Chapter 4: Designing the User Interface Open that file by double-clicking it, and you should see some XML in the Eclipse editor window, as shown in Figure 4-4. Figure 4-4: The main. xml layout file opened in Eclipse. Layouts are stored here. The main.xml layout file What you see in Figure 4-4 is a simple layout in which you have a text value in the middle of the screen. Just to be sure that you’re on the same page, your code should look like this: This XML file defines exactly what your view is to look like. In the following sections, I break this file down for you element by element. Default XML declaration The first element provides the default XML declaration, letting text editors like Eclipse and consumers like Android know what type of file it is: 09_9780470770184-ch04.indd 9709_9780470770184-ch04.indd 97 11/2/10 8:54 AM11/2/10 8:54 AM 98 Part II: Building and Publishing Your First Android Application Layout type The next element defines the layout type. In this case, you’re working with a LinearLayout. I give you more info about LinearLayouts in a moment, but for now, be aware that a LinearLayout is a container for other items known as views that show up on the screen. Notice how I am not showing the closing tag; this is because this tag is a container of other items. The close tag is inserted after all the view items have been added to the container: Views The “other items” I mention previously are known as views. Views in Android are the basic building blocks for user interface components. The following code shows TextView, which is responsible for displaying text to the screen: A view occupies a rectangular space on the screen and is responsible for draw- ing and event handling. All items that can show up on a device’s screen are all views. The View class is the superclass that all items inherit from in Android. At the end of it all, you have the closing tag for the LinearLayout. This closes the container: In the following section, I describe the forest that is filled with different types of layouts. Using the Android SDK’s layout tools When creating user interfaces, you sometimes have to lay components out relative to each other or in a table, or even under certain circumstances, using absolute positioning. Thankfully the engineering geniuses at Google who created Android thought of all this and provided you with the tools 09_9780470770184-ch04.indd 9809_9780470770184-ch04.indd 98 11/2/10 8:54 AM11/2/10 8:54 AM 99 Chapter 4: Designing the User Interface necessary to create those types of layouts. Table 4-2 gives you a brief intro- duction to the common types of layouts that are available in the Android Software Development Kit (SDK). Table 4-2 Android SDK Layouts Layout Description LinearLayout A layout that arranges its children in a single row. RelativeLayout A layout where the positions of the children can be described in relation to each other or to the parent. FrameLayout This layout is designed to block out an area on the screen to display a single item. You can add multiple children to a FrameLayout, but all children are pegged to the upper left of the screen. Children are drawn in a stack, with the most recently added child at the top of the stack. This layout is commonly used as a way to lay out views in an absolute position. TableLayout A layout that arranges its children into rows and columns. Other different types of layout tools exist, such as a TabHost for creating tabs and a Sliding Drawer for finger-swiping motions of hiding and displaying views. I’m not going to get into those at this point because they are only used in special-case scenarios. The items in Table 4-2 outline the layouts that you will use most commonly. Using the visual designer I have some good news for you: Eclipse includes a visual designer. I also have some bad news: The designer is limited in what it can do (as are all visual designers). Opening the visual designer To view the visual designer, with the main.xml file open in the Eclipse editor, click the Layout button (see Figure 4-5). 09_9780470770184-ch04.indd 9909_9780470770184-ch04.indd 99 11/2/10 8:54 AM11/2/10 8:54 AM 100 Part II: Building and Publishing Your First Android Application Figure 4-5: The Layout button, which shows the visual designer. Visual designer You should now see the visual designer, as shown in Figure 4-6. Figure 4-6: The visual designer. 09_9780470770184-ch04.indd 10009_9780470770184-ch04.indd 100 11/2/10 8:54 AM11/2/10 8:54 AM 101 Chapter 4: Designing the User Interface From here, you can drag and drop items from the Layouts or Views toolboxes. Inspecting a view’s properties A feature I really like about the designer is the ability to view the properties of a given view, just by clicking it. Most likely, your Properties panel is hidden. To show it, follow these steps: 1. Choose Window➪Show View➪Other. 2. Expand Java and choose Properties. This opens the Properties view in Eclipse, as shown in Figure 4-7. To use the Properties window, simply select a view in the visual designer. The view has a red border around it, and the properties show up in the Properties window below. Scroll through the list of properties to examine what can be changed in the view. Figure 4-7: A selected item in the visual designer with some of the properties listed in the Properties window. Red line around selected view View properties If you’re not sure what properties a view has, open the visual designer, click the Properties Tab, and inspect the Properties view. This gives you a quick 09_9780470770184-ch04.indd 10109_9780470770184-ch04.indd 101 11/2/10 8:54 AM11/2/10 8:54 AM 102 Part II: Building and Publishing Your First Android Application glance into what the view has to offer. If the Properties tab is not visible, enable it by choosing Windows➪Show View➪Other➪General➪Properties. A view’s available properties can change depending on its parent layout. For example, if a TextView is inside a LinearLayout, it has a different set of properties (for layout) than if it is inside a RelativeLayout. The visual designer works well for simple scenarios where your contents are static in nature. But what happens when you need to draw items on the screen dynamically based on user input? That’s where the designer falls down. It cannot help you in those scenarios. It is best suited for static content sce- narios. A static content scenario occurs when you create your layout once and it does not update dynamically. The text of TextViews or images might change, but the actual layout of the views inside the layout would not change. Developing the User Interface Okay, it’s time to start developing your user interface. The first thing to do is to return to the XML view of your layout by clicking the main.xml tab, which is directly next to the Layout tab that you clicked to get to the visual designer. When you are in the XML view, delete the TextView of your layout. Your layout should now look like this: Viewing XML layout attributes Before I go any further, let me explain the Android layout XML that you are currently working with. See Table 4-3. Table 4-3 XML Layout Attributes Layout Description xmlns:android=”...” This defines the XML namespace that you will use to reference part of the Android SDK. 09_9780470770184-ch04.indd 10209_9780470770184-ch04.indd 102 11/2/10 8:54 AM11/2/10 8:54 AM 103 Chapter 4: Designing the User Interface Layout Description orientation=”vertical” This informs Android that this view is to be laid out in a vertical fashion (like portrait format in printing). android:layout_ width=”fill_parent” This informs the view that it should fill as much horizontal space as it can, up to its parent. In short, it should make the width as wide as it can be within the parent. android:layout_ height=”fill_parent” This informs the view that it should fill as much vertical space as it can, up to its parent. In short, it should make the height as tall as it can be within the parent. At this point, you have defined your layout to fill the entire screen by setting the width and height to “fill_parent”. Working with views As stated previously, views in Android are the basic building blocks for user interface components. Anytime you implement a user interface component, such as a Layout, TextView, and so on, in the Android system, you are using a view. When you work with views in Java, you have to cast them to their appropriate type to work with them. Setting layout_width and layout_height values Before a view can be presented to the screen, a couple of settings must be configured on the view so that Android knows how to lay out the view on the screen. The attributes that are required are layout_width and layout_height. These are known as LayoutParams in the Android SDK. The layout_width attribute specifies the given width a view should be, and the layout_height attribute specifies the given height a view should be. Setting fill_parent and wrap_content values The layout_width and layout_height attributes can take any pixel value or density-independent pixel value to specify their respective dimen- sion. However, two of the most common values for layout_width and layout_height are fill_parent and wrap_content constants. The fill_parent value informs the Android system to fill as much space as possible on the screen based on the available space of the parent layout. The wrap_content value informs the Android system to only take up as much space as needed to show the view. As the view’s contents grow, as would 09_9780470770184-ch04.indd 10309_9780470770184-ch04.indd 103 11/2/10 8:54 AM11/2/10 8:54 AM 104 Part II: Building and Publishing Your First Android Application happen with a TextView, the view’s viewable space grows. This is similar to the Autosize property in Windows forms development. If you’re using a static layout, these two attributes must be set in the XML layout. If you’re creating views dynamically through code, the layout parame- ters must be set through Java code. Either way, you cannot be without them. I do not cover dynamic creation of views in this book. If you’d like to find out more about dynamic creation of views, see the API samples that come with the Android SDK. If you forget to provide values for layout_width or layout_height, your Android application will crash when rendering the view. Thankfully, you find this out real quickly when you test your application. As of Android 2.2, fill_parent has been renamed to match_parent. However, to maintain backward compatibility, fill_parent is still sup- ported, which is why I’m using it here. However, if you plan on developing for Android 2.2 and above, it would be best to use match_parent. Adding an Image to Your Application Now you need to put some stuff on the screen! Although looking at text is fun and all, the real interesting components are added through input mecha- nisms and images. In the following sections, I demonstrate how to include images in your application. Why you should worry about density folders Android supports various screen sizes and densities. Earlier, you placed an image in the mdpi folder, which is for medium-density devices. What about small- and large-density devices? If Android cannot find the requested resource in the desired density, it opts for a den- sity of the resource that it can find. What does this mean? If you’re running on a high-density screen, the image will be stretched out and most likely quite pixilated. If you’re running on a low-density device, it means that the image will be compressed to fit within the screen dimen- sions. To avoid this, create multiple versions of your image to target each screen density. For more information, see the Supporting Multiple Screens best practice guide in the Android doc- umentation located at http://developer. android.com/guide/practices/ screens_support.html. 09_9780470770184-ch04.indd 10409_9780470770184-ch04.indd 104 11/2/10 8:54 AM11/2/10 8:54 AM D o wnload from Wow! eBook 105 Chapter 4: Designing the User Interface Placing an image on the screen The first thing you add is the phone image to the screen. This is the phone image that you see in Figure 4-4, earlier in this chapter. First you need (uh, yeah) the phone image. You can download that from the book’s source code that is available online, or you can use your own. Adding images to your project is simple. We simply drag them over and then reference them in the project. 1. Drag the phone image into the res/drawable-mdpi folder in the Eclipse project, as shown in Figure 4-8. Figure 4-8: Dragging the image file into the res/ draw- able- mdpi folder. Notice that you see two states of the application: regular, as shown earlier in Figure 4-2, and silent, as shown earlier in Figure 4-3. 2. Drag the other phone image — the silent one (or one of your own) — into the res/drawable-mdpi folder. To follow along with the rest of the chapter, the names of the images should be as follows: • Regular mode image: phone_on.png • Silent mode image: phone_silent.png If your images are not named accordingly, you can rename them now. Your Eclipse project should now look like what is shown in Figure 4-9. 09_9780470770184-ch04.indd 10509_9780470770184-ch04.indd 105 11/2/10 8:54 AM11/2/10 8:54 AM 106 Part II: Building and Publishing Your First Android Application Figure 4-9: The Silent Mode Toggle project with the phone images. When you dragged the images into Eclipse, the ADT recognized that the proj- ect file structure changed. At that time, the ADT rebuilt the project because the Build Automatically selection is enabled in the Project menu. This regen- erated the gen folder, where the R.java file resides. The R.java file now includes a reference to the two new images that were recently added. You may now use these references to these resources to add images to your layout in code or in XML definition. You’re going to declare them in XML layout in the following section. Adding the image to the layout Now it’s time to add the image to the layout. To do that, you need to type the following into the main.xml file, overwriting the current contents of the file: 09_9780470770184-ch04.indd 10609_9780470770184-ch04.indd 106 11/2/10 8:54 AM11/2/10 8:54 AM 107 Chapter 4: Designing the User Interface In this step, you added the ImageView inside the LinearLayout. An ImageView allows you to project an image to the device’s screen. Setting image properties The ImageView contains a couple of extra parameters that you have not seen yet, so I cover those now: ✓ The android:id=”@+id/phone_icon” property: The id attribute defines the unique identifier for the view in the Android system. I gave it a good college try to come up with a better explanation of the android:id value nomenclature, but nothing beats the actual Android documentation on the subject, which is located at http://developer.android.com/ guide/topics/ui/declaring-layout.html. ✓ The layout_gravity property: This property defines how to place the view, both its x- and y-axis, with its parent. Here, I have defined the value as the center_horizontal constant. This value informs the Android system to place the object in the horizontal center of its con- tainer, not changing its size. You can use many other constants, such as center_vertical, top, bottom, left, right, and many more. See the LinearLayout.LayoutParams Android documentation for a full list. ✓ The android:src=”@drawable/phone_on” property: This property is a direct child of the ImageView class. You use this property to set the image that you would like to show up on the screen. Notice the value of the src property — “@drawable/phone_on”. What you’re seeing now is the use of the R.java file. Here, you can reference drawable resources through XML. This is done by typing the at symbol (@) and the resource you’re after. Setting drawable resources I did not type @drawable-mdpi for the drawable resource identifier; I typed @drawable. This is because it is Android’s job to support multiple screen sizes, not yours (which makes life easy for you!). The Android layout system knows about drawables and that’s all. It knows nothing of low-, medium-, or high-density drawables during design time. At run time, Android determines whether and when it can use low/medium/high-density drawables. For example, if the app is running on a high-density device and the requested drawable resource is available in the drawable-hdpi folder, Android uses that resource. Otherwise, it uses the closest match it can find. Supporting various screen sizes and densities is a large topic (and complex in some aspects). Therefore, for an in-depth view into this subject, read the Managing Multiple Screen Sizes best practice article in the Android documentation. 09_9780470770184-ch04.indd 10709_9780470770184-ch04.indd 107 11/2/10 8:54 AM11/2/10 8:54 AM 108 Part II: Building and Publishing Your First Android Application The phone_on portion identifies the drawable that you want to use. The image filename is actually phone_on.png. However to stay within Java’s member- naming guidelines, the file extension is removed, leaving phone_on. If you were to open the R.java file in the gen folder, you would see a member variable with the name of phone_on, not phone_on.png. Thanks to the ADT, you can see your available options for this property through code completion. Place your cursor directly after “@drawable/” in the src property of the ImageView in the Eclipse editor. Then press Ctrl+spacebar. You should see the code completion dialog box, as shown in Figure 4-10. See the other resource names in there? These are other options that you could also choose for the src portion of the drawable definition. Figure 4-10: Code com- pletion with resources. Code completion Creating a Launcher Icon for the Application When your app gets installed, it has an icon that helps users identify its pres- ence in the application launcher. When you created the Silent Mode Toggle application, the ADT automatically included a default launcher icon for you, as shown in Figure 4-11. 09_9780470770184-ch04.indd 10809_9780470770184-ch04.indd 108 11/2/10 8:54 AM11/2/10 8:54 AM 109 Chapter 4: Designing the User Interface Figure 4-11: The default Android 2.2 launcher icon. Well, that’s kind of bland, right? Exactly! You should change this icon to one of your own. I have a round phone icon that I created in an image-editing program, as shown in Figure 4-12. You can create your own (as shown in the following section) or use the one from the downloaded source code. Figure 4-12: The new phone appli- cation icon. Designing a custom launcher icon Creating your own launcher icons is fairly easy thanks to the Android proj- ect. The Android documentation contains a full article, entitled “Icon Design Guidelines, Android 2.0,” that covers all aspects of icon design. This article contains a how-to manual for creating icons for the Android platform. The article also contains a style guide, dos and don’ts, materials and colors, size and positioning guidelines, and best of all, icon templates that you can use. You can find all of the design guidelines at http://d.android.com/guide/ practices/ui_guidelines/icon_design.html. Working with templates Because you’ve already downloaded the Android SDK, these icon templates and materials are available for you to use right now on your hard drive! Navigate to your Android SDK installation directory (from Chapter 2), and from there navi- gate to the docs/shareables directory. There you’ll find various .zip files that contain templates and samples. Open the templates in the image-editing program of your choice and follow the design guidelines in the documentation to make your next rocking icon set. 09_9780470770184-ch04.indd 10909_9780470770184-ch04.indd 109 11/2/10 8:54 AM11/2/10 8:54 AM 110 Part II: Building and Publishing Your First Android Application Matching icon sizes with screen densities Because each different screen density requires a different-size icon, how do you know how big the icon should be when designing it? Each density must have its own icon size to look appropriate (no pixilation, stretching, or compressing) on the screen. Table 4-4 summarizes the finished icon sizes for each of the three generalized screen densities. Table 4-4 Finished Icon Sizes Screen Density Finished Icon Size Low-density screen (ldpi) 36 x 36 px Medium-density screen (mdpi) 48 x 48 px High-density screen (hdpi) 72 x 72 px Adding a custom launcher icon To place your custom launcher icon into the project, follow these steps: 1. Rename your image icon to icon.png. 2. Drag your icon into the mdpi folder. Eclipse asks whether you want to overwrite the existing icon.png, as shown in Figure 4-13. Click Yes. Figure 4-13: Eclipse asks whether it’s okay to overwrite the icon. png file. You need to think about multiple densities when working with images. Icons are no different. You need to create three different versions of your icon 09_9780470770184-ch04.indd 11009_9780470770184-ch04.indd 110 11/2/10 8:54 AM11/2/10 8:54 AM 111 Chapter 4: Designing the User Interface (low-density, medium-density, and high-density) for it to show up correctly on the various devices. How to create your own launcher icons is discussed in the Android Design Guidelines, located at http://d.android.com/guide/ practices/ui_guidelines/icon_design.html. You’re not done yet! What about the ldpi and hdpi folders? You need a low-density version of your icon as well as a high-density version. Copy those respective icons into the ldpi and hdpi folders. If you don’t copy the low- and high-density icons into their respective folders, users who have a low- or high-density device receive the default launcher icon, as shown in Figure 4-11, earlier in this chapter, whereas the medium- density devices receive the new icon that you dragged into the project. How does this happen? You dragged the file into the mdpi folder; what gives? The hdpi and ldpi folders both contain their own version of the icon. Open the drawable-hdpi an drawable-ldpi folders in your Eclipse project and you can see that each density has its own icon.png file. Be sure to place the correct-size icon in each density-specific folder. Adding a Toggle Button Widget A widget is a View object that serves as an interface for interaction with the user. Android devices come fully equipped with various widgets that include buttons, check boxes, and text-entry fields so that you can quickly build your user interface. Some widgets are more complex, such as a date picker, a clock, and zoom controls. Widgets also provide user interface events that inform you when a user has interacted with the particular widget, such as tapping a button. The Android documentation can get a bit sticky at times and it is important to note that widgets and app widgets are regularly confused. They are two completely different topics. I am currently referring to widgets in the sense that you can find defined at http://d.android.com/guide/practices/ ui_guidelines/widget_design.html. You need to add a button widget to your application so that you can toggle the silent mode on the phone. To add a button to your layout, type the following code after the ImageView that you added before: 09_9780470770184-ch04.indd 11109_9780470770184-ch04.indd 111 11/2/10 8:54 AM11/2/10 8:54 AM 112 Part II: Building and Publishing Your First Android Application
还剩387页未读

继续阅读

下载pdf到电脑,查找使用更方便

pdf的实际排版效果,会与网站的显示效果略有不同!!

需要 8 金币 [ 分享pdf获得金币 ] 0 人已下载

下载pdf