Android Programming Tutorials
by Mark L. Murphy
Android Programming Tutorials
by Mark L. Murphy
Copyright © 2009-2011 CommonsWare, LLC. All Rights Reserved. Printed
in the United States of America.
CommonsWare books may be purchased in printed (bulk) or digital form for educational or business
use. For more information, contact direct@commonsware.com.
Printing History:
Mar 2011: Version 3.2
ISBN: 978-0-9816780-4-7
The CommonsWare name and logo, "Busy Coder's Guide", and related trade dress are trademarks of
CommonsWare, LLC.
All other trademarks referenced in this book are trademarks of their respective firms.
The publisher and author(s) assume no responsibility for errors or omissions or for damages resulting
from the use of the information contained herein.
3
Table of Contents
Welcome to the Warescription! ................................................................... xiii
Preface ............................................................................................................ xv
Welcome to the Book! ............................................................................................ xv
Prerequisites ............................................................................................................ xv
Using the Tutorials ................................................................................................ xvi
Warescription ...................................................................................................... xviii
What's New ......................................................................................................... xviii
About the "Further Reading" Sections ................................................................. xix
Errata and Book Bug Bounty ................................................................................ xix
Source Code License ............................................................................................... xx
Creative Commons and the Four-to-Free (42F) Guarantee .............................. xxi
Lifecycle of a CommonsWare Book ..................................................................... xxi
Roster of Tutorials ................................................................................................xxii
Your First Android Project................................................................................ 1
Step #1: Create the New Project ............................................................................... 1
Step #1: Eclipse ................................................................................................... 2
Step #2: Command Line .................................................................................... 5
Step #2: Build, Install, and Run the Application in Your Emulator or
Device ........................................................................................................................ 6
iii
Step #1: Eclipse ................................................................................................... 6
Step #2: Command Line .................................................................................... 7
A Simple Form ................................................................................................. 11
Step-By-Step Instructions ....................................................................................... 11
Step #1: Generate the Application Skeleton ................................................... 11
Step #2: Modify the Layout .............................................................................. 12
Step #3: Support All Screen Sizes ................................................................... 14
Step #4: Compile and Install the Application ................................................ 15
Step #5: Run the Application in the Emulator ............................................... 15
Step #6: Create a Model Class ........................................................................ 16
Step #7: Save the Form to the Model ............................................................. 16
Extra Credit ............................................................................................................. 18
Further Reading ...................................................................................................... 18
A Fancier Form ................................................................................................ 19
Step-By-Step Instructions ...................................................................................... 19
Step #1: Switch to a TableLayout .................................................................... 19
Step #2: Add a RadioGroup ............................................................................. 21
Step #3: Update the Model ............................................................................. 23
Step #4: Save the Type to the Model ............................................................. 24
Extra Credit ............................................................................................................. 26
Further Reading ...................................................................................................... 27
Adding a List .................................................................................................. 29
Step-By-Step Instructions ...................................................................................... 29
Step #1: Hold a List of Restaurants ................................................................ 29
Step #2: Save Adds to List ............................................................................... 30
Step #3: Implement toString()......................................................................... 31
Step #4: Add a ListView Widget ..................................................................... 31
iv
Step #5: Build and Attach the Adapter .......................................................... 33
Extra Credit ............................................................................................................. 35
Further Reading ...................................................................................................... 36
Making Our List Be Fancy ...............................................................................37
Step-By-Step Instructions ...................................................................................... 37
Step #1: Create a Stub Custom Adapter ......................................................... 38
Step #2: Design Our Row ................................................................................ 38
Step #3: Override getView(): The Simple Way .............................................40
Step #4: Create a RestaurantHolde ............................................................... 41
Step #5: Recycle Rows via RestaurantHolde ................................................ 42
Extra Credit ............................................................................................................. 45
Further Reading ...................................................................................................... 45
Splitting the Tab ............................................................................................ 47
Step-By-Step Instructions ...................................................................................... 47
Step #1: Rework the Layout............................................................................. 47
Step #2: Wire In the Tabs ...............................................................................49
Step #3: Get Control On List Events ............................................................... 51
Step #4: Update Our Restaurant Form On Clicks ......................................... 51
Step #5: Switch Tabs On Clicks ...................................................................... 52
Extra Credit ............................................................................................................. 56
Further Reading ...................................................................................................... 56
Menus and Messages ......................................................................................57
Step-By-Step Instructions ...................................................................................... 57
Step #1: Add Notes to the Restaurant ............................................................ 57
Step #2: Add Notes to the Detail Form ......................................................... 58
Step #3: Define the Option Menu ................................................................. 60
Step #4: Show the Notes as a Toast ............................................................... 61
v
Extra Credit ............................................................................................................. 67
Further Reading ...................................................................................................... 67
Sitting in the Background ..............................................................................69
Step-By-Step Instructions ..................................................................................... 69
Step #1: Initialize the Progress Bar ................................................................ 69
Step #2: Create the Work Method ................................................................. 70
Step #3: Fork the Thread from the Menu ....................................................... 71
Step #4: Manage the Progress Ba ................................................................... 73
Extra Credit ............................................................................................................. 75
Further Reading ...................................................................................................... 76
Life and Times ................................................................................................ 77
Step-By-Step Instructions ...................................................................................... 77
Step #1: Lengthen the Background Work ...................................................... 77
Step #2: Pause in onPause() ............................................................................ 78
Step #3: Resume in onResume() .................................................................... 79
Extra Credit .............................................................................................................86
Further Reading ......................................................................................................86
A Few Good Resources ................................................................................... 87
Step-By-Step Instructions ...................................................................................... 87
Step #1: Review our Current Resources ......................................................... 87
Step #2: Create a Landscape Layout ..............................................................88
Extra Credit ............................................................................................................. 91
Further Reading ...................................................................................................... 92
The Restaurant Store ..................................................................................... 93
Step-By-Step Instructions ...................................................................................... 93
Step #1: Create a Stub SQLiteOpenHelper .................................................... 93
Step #2: Manage our Schema .........................................................................94
vi
Step #3: Remove Extraneous Code from LunchList ..................................... 95
Step #4: Get Access to the Helper .................................................................. 95
Step #5: Save a Restaurant to the Database ................................................. 96
Step #6: Get the List of Restaurants from the Database .............................. 97
Step #7: Change our Adapter and Wrapper ................................................. 98
Step #8: Clean Up Lingering ArrayList References .................................... 100
Step #9: Refresh Our List ............................................................................... 101
Extra Credit ........................................................................................................... 106
Further Reading .................................................................................................... 107
Getting More Active ..................................................................................... 109
Step-By-Step Instructions .................................................................................... 109
Step #1: Create a Stub Activity ...................................................................... 109
Step #2: Launch the Stub Activity on List Click .......................................... 110
Step #3: Move the Detail Form U ................................................................... 111
Step #4: Clean Up the Original UI ................................................................ 115
Step #5: Pass the Restaurant _ID .................................................................. 116
Step #6: Load the Restaurant Into the Form ............................................... 117
Step #7: Add an "Add" Menu Option............................................................ 118
Step #8: Detail Form Supports Add and Edit .............................................. 119
Extra Credit ............................................................................................................ 132
Further Reading ..................................................................................................... 133
What's Your Preference? ............................................................................... 135
Step-By-Step Instructions ..................................................................................... 135
Step #1: Define the Preference XML ............................................................. 135
Step #2: Create the Preference Activity ....................................................... 136
Step #3: Connect the Preference Activity to the Option Menu. ................ 137
Step #4: Apply the Sort Order on Startup .................................................... 141
vii
Step #5: Listen for Preference Changes ....................................................... 142
Step #6: Re-Apply the Sort Order on Changes ........................................... 143
Extra Credit ........................................................................................................... 144
Further Reading .................................................................................................... 145
Turn, Turn, Turn ........................................................................................... 147
Step-By-Step Instructions .................................................................................... 147
Step #1: Add a Stub onSaveInstanceState( .................................................. 147
Step #2: Pour the Form Into the Bundle ..................................................... 148
Step #3: Repopulate the Form ...................................................................... 148
Step #4: Fix Up the Landscape Detail Form ............................................... 148
Extra Credit ........................................................................................................... 150
Further Reading ..................................................................................................... 151
Feeding at Lunch .......................................................................................... 153
Step-By-Step Instructions ..................................................................................... 153
Step #1: Add a Feed URL to the Data Model ................................................ 153
Step #2: Update the Detail Form...................................................................157
Step #3: Add a Feed Options Menu Item ..................................................... 161
Step #4: Add Permissions and Check Connectivity ................................... 162
Step #5: Install the RSS Library .................................................................... 166
Step #6: Fetch and Parse the Feed ............................................................... 167
Step #7: Display the Feed Items ................................................................... 170
Extra Credit ........................................................................................................... 179
Further Reading .................................................................................................... 180
Serving Up Lunch .......................................................................................... 181
Step-By-Step Instructions ..................................................................................... 181
Step #1: Create an Register a Stub IntentService ......................................... 181
Step #2: Move Feed Fetching and Parsing to the Service .......................... 183
viii
Step #3: Send the Feed to the Activity ......................................................... 184
Step #4: Display the Feed Items, Redux ...................................................... 186
Extra Credit ........................................................................................................... 192
Further Reading .................................................................................................... 193
Locating Lunch ............................................................................................. 195
Step-By-Step Instructions .................................................................................... 195
Step #1: Add Latitude and Longitude to the Data Mode ........................... 195
Step #2: Save the Restaurant in onPause()................................................. 200
Step #3: Add a TextView and Options Menu Item for Location ............... 201
Step #4: Update the Permissions .................................................................205
Step #5: Find Our Location Using GPS ...................................................... 206
Step #6: Only Enable Options Menu Item If Saved .................................. 209
Extra Credit ............................................................................................................ 215
Further Reading .................................................................................................... 216
Putting Lunch on the Map ............................................................................ 217
Step-By-Step Instructions .....................................................................................217
Step #1: Add an Options Menu Item for Map ............................................. 218
Step #2: Create and Use a MapActivity ....................................................... 218
Step #3: Create an ItemizedOverlay .............................................................221
Step #4: Handle Marker Taps ....................................................................... 230
Extra Credit ........................................................................................................... 235
Further Reading .................................................................................................... 236
Is It Lunchtime Yet? ...................................................................................... 237
Step-By-Step Instructions .................................................................................... 237
Step #1: Create a TimePreference ................................................................. 238
Step #2: Collect Alarm Preferences .............................................................. 241
Step #3: Set Up a Boot-Time Receiver .........................................................242
ix
Step #4: Manage Preference Changes ......................................................... 244
Step #5: Display the Alarm ............................................................................251
Extra Credit ........................................................................................................... 257
Further Reading .................................................................................................... 258
More Subtle Lunch Alarms .......................................................................... 259
Step-By-Step Instructions ....................................................................................259
Step #1: Collect Alarm Style Preference ...................................................... 260
Step #2: Display the Alarm, Redux ............................................................. 260
Extra Credit .......................................................................................................... 268
Further Reading ................................................................................................... 268
How To Get Started ...................................................................................... 269
Java..........................................................................................................................270
Step #1: Install the JDK ..................................................................................270
Step #2: Learn Java .........................................................................................270
Install the Android SDK ....................................................................................... 271
Step #1: Install the Base Tools .......................................................................271
Step #2: Install the SDKs and Add-Ons ....................................................... 272
Install the ADT for Eclipse ...................................................................................276
Install Apache Ant ................................................................................................278
Set Up the Emulator .............................................................................................279
Set Up the Device ................................................................................................ 286
Step #1: Windows ...........................................................................................287
Step #2: OS X and Linux .............................................................................. 288
Coping with Eclipse ...................................................................................... 291
How to Import a Non-Eclipse Project ................................................................ 291
How to Get To DDMS ......................................................................................... 296
How to Create an Emulator ................................................................................ 298
x
How to Run a Project .......................................................................................... 299
How Not to Run Your Project .............................................................................300
How to Get Past Eclipse .......................................................................................300
xi
12
Welcome to the Warescription!
We hope you enjoy this ebook and its updates - subscribe to the Warescription
newsletter on theWarescription site to learn when new editions of this book, or
other books, are available.
All editions of CommonsWare titles, print and ebook, follow a software-style
numbering system. Major releases (1.0, 2.0, etc.) are available in both print and
ebook; minor releases (0.1, 0.9, etc.) are available in ebook form for Warescription
subscribers only. Releases ending in .9 are "release candidates" for the next major
release, lacking perhaps an index but otherwise being complete.
Each Warescription ebook is licensed for the exclusive use of its subscriber and is
tagged with the subscriber's name. We ask that you not distribute these books.
Ifyouwork for a firm and wish to have several employees have access, enterprise
Warescriptions are available. Just contact us at enterprise@commonsware.com.
Also, bear in mind that eventually this edition of this title will be released under a
Creative Commons license - more on this in the preface.
Remember that the CommonsWareWeb site has errataand resources (e.g.,
sourcecode) for each of our titles. Just visit the Web page for the book you are
interested in and follow the links.
You can search through the PDF using most PDF readers (e.g., Adobe Reader). If
you wish to search all of the CommonsWare books at once, and
xiii
your operating system does not support that directly, you can always combine the
PDFs into one, using tools like PDF Split-And-Merge or the Linux command pdftk
*.pdf cat output combined.pdf.
xiv
Preface
Welcome to the Book!
If you come to this book after having read its companion volumes, The Busy
Coder's Guide to Android Development and The Busy Coder's Guide to Advanced
Android Development, thanks for sticking with the series! CommonsWare aims to
have the most comprehensive set of Android development resources (outside of
the Open Handset Alliance itself), and we appreciate your interest.
If you come to this book having learned about Android from other sources, thanks
for joining the CommonsWare community!
Prerequisites
This book is a collection of tutorials, walking you through developing Android
applications, from the simplest "Hello, world!" to applications using many
advanced Android APIs.
Since this book only supplies tutorials, you will want something beyond it as a
reference guide. That could be simply the Android SDK documentation, available
with your SDK installation or online. It could be the other books in the
CommonsWare Android series. Or, it could be another Android book - a list of
currently-available Android books can be found on the Android Programming
knol. What you do not want to do is
xv
attempt to learn all of Android solely from these tutorials, as they will demonstrate
the breadth ofthe Android API but not its depth.
Also, the tutorials themselves have varying depth. Early on, there is more "handholding" to explain every bit of what needs to be done (e.g., classes to import). As
the tutorials progress, some of the simpler Java bookkeeping steps are left out of
the instructions - such as exhaustive lists of import statements - so the tutorials
can focus on the Android aspects of the code.
fou can find out when new releases of this book are available via:
•
The cw-android Google Group, which is also a great place to ask questions
about the book and its examples
•
The commonsguy Twitter feed
•
The CommonsBlog
•
The Warescription newsletter, which you can subscribe to off of your
Warescription page
Using the Tutorials
Each tutorial has a main set of step-by-step instructions, plus an "Extra Credit"
section. The step-by-step instructions are intended to guide you through creating
or extending Android applications, including all code you need to enter and all
commands you need to run. The "Extra Credit" sections, on the other hand,
provide some suggested areas for experimentation beyond the base tutorial,
without step-by-step instructions.
If you wish to start somewhere in the middle of the book, or if you only wish to do
the "Extra Credit" work, or if you just want to examine the results without doing
the tutorials directly yourself, you can download the results of each tutorial's stepby-step instructions from the book's github repository. You can either clone the
repository, or click the Download Source button in the upper-right to get the
source as a ZIP file. The source code is organized by tutorial number, so you can
readily find the project(s) associated with a particular tutorial from the book.
xvi
Note that while you are welcome to copy and paste code out of the book, you may
wish to copy from the full source code instead. A side-effect of the way the source
code listings are put into this book makes them difficult to copy from some PDF
viewers, for example.
The tutorials do not assume you are using Eclipse, let alone any other specific
editor or debugger. The instructions included in the tutorials will speak in general
terms when it comes to tools outside of those supplied by
the Android SDK itself.
The code for the tutorials has been tested most recently on Android 2.2. It should
work on older versions as well, on the whole.
The tutorials include instructions for both Linux and Windows XP OS X
developers should be able to follow the Linux instructions in general, making
slight alterations as needed for your platform. Windows Vista users should beable
to follow the Windows XP instructions in general, tweaking the steps to deal with
Vista's directory structure and revised Start menu.
If you wish to use the source code from the CommonsWare Web site, bear in mind
a few things:
1.
The projects are set up to be built by Ant, not by Eclipse. If you wish to use
the code with Eclipse, you will need to create a suitable Android Eclipse
project and import the code and other assets.
2.
You should delete build.xml, then run android update project -p ...
(where ... is the path to a project of interest) on those projects you wish to
use, so the build files are updated for your Android SDK version.
Also, please note that the tutorials are set up to work well on HVGA and larger
screen sizes. Using them on QVGA or similar sizes is not recommended.
xvii
Warescription
This book will be published both in print and in digital form. The digital versions
of all CommonsWare titles are available via an annual subscription - the
Warescription.
The Warescription entitles you, for the duration of your subscription, to digital
forms of all CommonsWare titles, not just the one you are reading. Presently,
CommonsWare offers PDF and Kindle; other digital formats will be added based
on interest and the openness ofthe format.
Each subscriber gets personalized editions of all editions of each title: both those
mirroring printed editions and in-between updates that are only available in digital
form. That way, your digital books are never out of date for long, and you can take
advantage of new material as it is made available instead of having to wait for a
whole new print edition. For example, when new releases of the Android SDK are
made available, this book will be quickly updated to be accurate with changes in
the APIs.
From time to time, subscribers will also receive access to subscriber-only online
material, including not-yet-published new titles.
Also, if you own a print copy of a CommonsWare book, and it is in good clean
condition with no marks orstickers, you can exchange that copy fora free fourmonth Warescription.
If you are interested in a Warescription, visit the Warescription section of the
CommonsWare Web site.
What's New
For those of you who have a Warescription, or otherwise have been keeping up
with this book, here is what is new in this version:
•
The Patchy examples were removed en masse
•
New tutorials (15-20) were added, continuing the LunchList sample
xviii
•
The source code repository for the samples was moved, so that links to the
old Patchy samples out on the Internet would continue to work
•
The tutorials were tested on Android 3.0
About the "Further Reading" Sections
Each tutorial has, at the end, a section named "Further Reading". Here, we list
places to go learn more about the theory behind the techniques illustrated in the
preceding tutorial. Bear in mind, however, that the Internet is fluid, so links may
not necessarily work. And, of course, there is no good way to link to other books.
Hence, the "Further Reading" section describes where you can find material, but
actually getting there may require a few additional clicks on your part. We
apologize for the inconvenience.
Errata and Book Bug Bounty
Books updated as frequently as CommonsWare's inevitably have bugs. Flaws.
Errors. Even the occasional gaffe, just to keep things interesting. You will find a
listof the known bugs on the errata page on the CommonsWare Web site.
But, there are probably even more problems. If you find one, please let us know!
Be the first to report a unique concrete problem in the current digital edition, and
we'll give you a coupon for a six-month Warescription as a bounty for helping us
deliver a better product. You can use that coupon to get a new Warescription,
renew an existing Warescription, or give the coupon to a friend, colleague, or some
random person you meet on the subway.
By "concrete" problem, we mean things like: •
Typographical errors
xix
Sample applications that do not work as advertised, in the environment
described in the book
Factual errors that cannot be open to interpretation
By "unique", we mean ones not yet reported. Each book has an errata page on the
CommonsWare Web site; most known problems will be listed there. One coupon
is given per email containing valid bug reports.
NOTE: Books with version numbers lower than 0.9 are ineligible for the bounty
program, as they are in various stages of completion. We appreciate bug reports,
though, if you choose to share them with us.
We appreciate hearing about "softer" issues as well, such as:
•
Places where you think we are in error, but where we feel our
interpretation is reasonable
•
Places where you think we could add sample applications, or expand upon
the existing material
•
Samples that do not work due to "shifting sands" of the underlying
environment (e.g., changed APIs with new releases of an SDK)
However, those "softer" issues do not qualify for the formal bounty program.
Be sure to check the book's errata page, though, to see if your issue has already
been reported.
Questions about the bug bounty, or problems you wish to report for bounty
consideration, should be sent to CommonsWare.
Source Code License
The source code samples shown in this book are available for download from the
book's GitHub repositor . All of the Android projects are licensed under the
Apache 2.0 License, in case you have the desire to reuse any of it.
xx
Creative Commons and the Four-to-Free (42F)
Guarantee
Each CommonsWare book edition will be available for use under the Creative
Commons Attribution-Noncommercial-ShareAlike 3.0 license as of the fourth
anniversary of its publication date, or when 4,000 copies of the edition have been
sold, whichever comes first. That means that, once four years have elapsed
(perhaps sooner!), you can use this prose for noncommercial purposes. That is our
Four-to-Free Guarantee to our readers and the broader community. For the
purposes of this guarantee, new Warescriptions and renewals will be counted as
sales of this edition, starting from the time the edition is published.
This edition of this book will be available under the aforementioned Creative
Commons license on March 1, 2015. Of course, watch the CommonsWare Web site,
as this edition might be relicensed sooner based on sales.
For more details on the Creative Commons Attribution-NoncommercialShareAlike 3.0 license, visit the Creative Commons Web site.
Note that future editions of this book will become free on later dates, each four
years from the publication of that edition or based on sales of that specific edition.
Releasing one edition under the Creative Commons license does not automatically
release all editions under that license.
Lifecycle of a CommonsWare Book
CommonsWare books generally go through a series of stages.
First are the pre-release editions. These will have version numbers below 0.9 (e.g.,
0.2). These editions are incomplete, often times having but a few chapters to go
along with outlines and notes. However, we make them available to those on the
Warescription so they can get early access to the material.
xxi
Release candidates are editions with version numbers ending in ".9" (0.9, 1.9, etc.).
These editions should be complete. Once again, they are made available to those
on the Warescription so they get early access to the material and can file bug
reports (and receive bounties in return!).
Major editions are thosewithversion numbers ending in ".0" (1.0, 2.0, etc.). These
will be first published digitally for the Warescription members, but will shortly
thereafter be available in print from booksellers worldwide.
Versions between a major edition and the next release candidate (e.g., 1.1, 1.2) will
contain bug fixes plus new material. Each of these editions should also be
complete, in that you will not see any "TBD" (to be done) markers or the like.
However, these editions may have bugs, and so bug reports are eligible for the
bounty program, as with release candidates and major releases.
A book usually will progress fairly rapidly through the pre-release editions to the
first release candidate and Version 1.0 - often times, only a few months. Depending
on the book's scope, it may go through another cycle of significant improvement
(versions 1.1 through 2.0), though this may take several months to ayear or more.
Eventually, though, the book willgo into more of a "maintenance mode", only
getting updates to fix bugs and deal with major ecosystem events - for example, a
new release of the Android SDK will necessitate an update to all Android books.
Roster of Tutorials
Here is what you can expect in going through the tutorials in this book:
1.
We startoff witha simple throwaway project, just to makesureyou have the
development tools all set up properly.
2.
We then begin creating LunchList, an application to track restaurants
where you might wish to go for lunch. In this tutorial, we set up a simple
form to collect basic information about a restaurant, such as a name and
address.
3.
We expand the form to add radio buttons for the type of restaurant (e.g.,
takeout).
xxii
4. Instead of tracking just a single restaurant, we add support for a list of
restaurants - but each restaurant shows up in the list only showing its
name.
5.
We extend the list to show the name and address of each restaurant, plus
an icon for the restaurant type.
6. To give us more room, we split the UI into two tabs, one for the list of
restaurants, and one for the detail form for a restaurant.
7.
We experiment with an options menu (the kind that appears when you
press the MENU button on a phone) and display a pop-up message.
8. We learn how to start a background thread and coordinate
communications between the background thread and the main
("UI") thread.
9. We learn how to find out when the activity is going off-screen, stopping
and restarting our background thread as needed.
10. We create a separate UI description for what the tabs should look like
when the phone is held in a landscape orientation.
11. We finally add database support, so your restaurant data persists from run
to run of the application.
12. We eliminate the tabs and split the UI into two separate screens
("activities"), one for the list of restaurants, and one for the detail form to
add or edit a restaurant.
13. We establish a shared preference - and an activity to configure it -to allow
the user to specify the sort order of the restaurants in the list.
14. We re-establish the landscape version of our UI (lost when we eliminated
the tabs inTutorial 12) and experiment with how to handle the orientation
changing during execution of our application.
15. We retrieve an RSS feed for our restaurant and display its results in a
separate activity
16. We move the RSS fetch-and-parse logic to a service
17. We give the user the ability to record the GPS coordinates of a restaurant
xxiii
18. Given those GPS coordinates, wegive the user theability to display where
the restaurant is on a map
19. We add an option for the user to have a "lunchtime alarm" that will let
them know when it is time for lunch
20. We extend the alarm to either pop up an activity (as before) or display a
status bar icon
xxiv
PART I - Core Tutorials
Welcome to the Book!
TUTORIAL 1
Your First Android Project
There are two major steps for getting started with Android:
1.
You need to install the Android SDK and developer tools
2.
You should build a test project to confirm that those tools are properly
installed and configured
If you have already done some form of "hello, world" project with the development
tools on your development machine, you can skip this tutorial.
If you have not yet installed the Android SDK and related tools, there is an
appendix that covers this process. Once you have the Android SDK, it is time to
make your first Android project. The good news is that this requires zero lines of
code - Android's tools create a "Hello, world!" application for you as part of
creating a new project. All you need to do is build it, install it, and see it come up
on your emulator or device. That is what this tutorial is for.
Step #1: Create the New Project
Android's tools can create a complete skeleton project for you, with everything you
need for a complete (albeit very trivial) Android application.
1
Your First Android Project
The only real difference comes from whether you are using Eclipse or the
command line.
Step #1: Eclipse
From the Eclipse main menu, choose File | New | Project..., and this will bring up a
list of project types to choose from. Fold open the Android option and click on
Android Project:
Figure 1. Eclipse New Project Wizard
Pres Next to advance the wizard to the main Android project page:
2
Your First Android Project
Figure 2. Eclipse New Project Wizard, Android Project
Fill in the following:
•
The name of the project (e.g., Now)
•
The Android SDK you wish to compile against (e.g., Google APIs for
Android 2.3)
•
The name of the Java package in which this project goes (e.g.,
com.commonsware.android.skeleton)
3
Your First Android Project
•
The name of the initial activity to create (e.g., Now)
Figure 3. Eclipse New Project Wizard, Android Project (continued)
At this point, clicking Finish will create your Eclipse project.
4
Your First Android Project
Step #2: Command Line
Here is a sample command that creates an Android project from the command
line:
android create project --target "Google Inc.:Google APIs:7" --path Skeleton/Now --activity
Now --package com.commonsware.android.skeleton
This will create an application skeleton for you, complete with everything you
need to build your first Android application: Java source code, build instructions,
etc. However, you are probably going to need to customize this somewhat. Here
are what those command-line switches mean:
•
--target
indicates what version of Android you are "targeting" in terms of
your build process. You need to supply the ID of a target that is installed
on your development machine, one you downloaded via the SDK and AVD
Manager. You can find out what targets are available via the android list
targets command. Typically, your build process will target the newest
version of Android that you have available.
•
--path
•
--activity
•
--package
indicates where you want the project files to be generated. Android
will create a directory if the one you name does not exist. For example, in
the command shown above, a Skeleton/Now/ directory will be created (or
used if it exists) underneath the current working directory, and the project
files will be stored there.
indicates the Java class name of your first activity for this
project. Do not include a package name, and the name has to meet Java
class naming conventions.
indicates the Java package in whichyour first activity will be
located. This package also uniquely identifies your project on any device
on which you install it, and this package also needs to be unique on the
Android Market if you plan on distributing your application there. Hence,
typically, you construct your package based on a domain name you own
(e.g., com.commonsware.android.skeleton), to reduce the odds of an
accidental package name collision with somebody else.
5
Your First Android Project
For your development machine, you will need to pick asuitable target, and you
may wish to change the path. The activity and package you can leave alone for
now.
Step #2: Build, Install, and Run the Application
in Your Emulator or Device
Having a project is nice and all, but it would be even better if we could build and
run it, whether on the Android emulator oryour Android device. Once again, the
process differs somewhat depending on whether you are using Eclipse or not.
Step #1: Eclipse
With your project selected in the Package Explorer pane, click the green "play"
button in the Eclipse toolbar to run your project. The first time you do this, you
will have to go through a few steps to set up a "run configuration", so Eclipse
knows what you want to do.
First, in the "Run As" list, choose "Android Application":
Figure 4. Eclipse "Run As" List
6
Your First Android Project
If you have more than one emulator AVD or device available, you will then get an
option to choose which you wish to run the application on. Otherwise, ifyoudo not
have a device plugged in, the emulator will start up with the AVD you created
earlier. Then, Eclipse will install the application on your device or emulator and
start it up.
Step #2: Command Line
For developers not using Eclipse, in your terminal, change into the Skeleton/Now
directory, then run the following command:
ant clean install
The Ant-based build should emit a list of steps involved in the installation process,
which look like this:
Buildfile: /home/some-balding-guy/projects/Skeleton/Now/build.xml
[setup] Android SDK Tools Revision 8
[setup] Project Target: Google APIs [setup] Vendor: Google Inc.
[setup] Platform Version: 2.1-update1
[setup] API level: 7
[setup]
[setup]-------------[setup] Resolving library dependencies:
[setup] No library dependencies.
[setup]
[setup]-------------[setup]
[setup] WARNING: No minSdkVersion value set. Application will install on all
Android versions.
[setup]
[setup] Importing rules file: tools/ant/main_rules.xml
clean:
[delete] Deleting directory /home/some-balding-guy/projects/Skeleton/Now/bin
-debug-obfuscation-check:
-set-debug-mode:
-compile-tested-if-test:
-dirs:
[echo] Creating output directories if needed...
[mkdir] Created dir: /home/some-balding-guy/projects/Skeleton/Now/bin
7
Your First Android Project
[mkdir] Created dir: /home/some-balding-guy/projects/Skeleton/Now/gen
[mkdir] Created dir: /home/some-balding-guy/projects/Skeleton/Now/bin/classes
-pre-build:
-resource-src:
[echo] Generating R.java / Manifest.java from the resources...
-aidl:
[echo] Compiling aidl files into Java classes...
-pre-compile:
compile:
[javac] /opt/android-sdk-linux/tools/ant/main_rules.xml:361: warning:
'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to
false for repeatable builds
[javac] Compiling 2 source files to /home/some-baldingguy/projects/Skeleton/Now/bin/classes
-post-compile:
-obfuscate:
-dex:
[echo] Converting compiled files and external libraries into /home/some-baldingguy/projects/Skeleton/Now/bin/classes.dex...
-package-resources:
[echo] Packaging resources
[aapt] Creating full resource package...
-package-debug-sign:
[apkbuilder] Creating Now-debug-unaligned.apk and signing it with a debug key...
debug:
[echo] Running zip align on final apk...
[echo] Debug Package: /home/some-balding-guy/projects/Skeleton/Now/bin/Now-debug.apk
BUILD SUCCESSFUL
Total time: 4seconds
Note the BUILD SUCCESSFUL at the bottom - that is how you know the application
compiled successfully.
When you have a clean build, in your emulator or device, open up the application
launcher, typically found at the bottom of the home screen:
8
Your First Android Project
Figure 5. Android emulator application launcher
Notice there is an icon for your Now application. Click on it to open it and see your
first activity in action.To leave the application and return to the launcher, press
the "BACK button", located to the right of the [MENU] button, and looks like an
arrow pointing to the left.
9
10
TUTORIAL 2
A Simple Form
This tutorial is the first of several that will build up a "lunch list" application,
where you can track various likely places to go to lunch. While this application
may seem silly, it will give you a chance to exercise many features of the Android
platform. Besides, perhaps you may even find the application to be useful
someday.
Step-By-Step Instructions
Here is how you can create this application:
Step #1: Generate the Application Skeleton
First, we need to create a new project.
Eclipse
Use the new-project wizard to create an empty Android project named LunchList,
as described in the Android developer documentation. This will create an
application skeleton for you, complete with everything you need to build your first
Android application: Java source code, build instructions, etc.
In particular:
11
A Simple Form
Choose a build target that is API Level 9 or higher and has the Google
APIs, so you can add a map to the application later in this book
Name the project LunchList, with an initial activity also named LunchList
Use apt.tutorial for the package name
Outside of Eclipse
Inside your terminal (e.g., Command Prompt for Windows), switch to some
directory where you would like the project to be created . Then, run the following
command:
android create project --target "Google Inc.:Google APIs:9" --path ./LunchList --activity
LunchList --package apt.tutorial
This will create an application skeleton for you, complete with everything you
need to start building the LunchList application.
Step #2: Modify the Layout
Using your text editor, open the LunchList/res/layout/main.xml file. Initially, that
file will look like this:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Hello World, LunchList"
/>
</LinearLayout>
Change that layout to look like this:
12
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/androidhttp://schemas.android.com/apk
/res/android" android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent" >
<LinearLayout
android:orientation="horizontal"
android:layout_width="fill_parent"
android:layout_height="wrap_content" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Name:"
/>
<EditText android:id="@+id/name"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
/>
</LinearLayout>
<LinearLayout
android:orientation="horizontal"
android:layout_width="fill_parent"
android:layout_height="wrap_content" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Address:"
/>
<EditText android:id="@+id/addr"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
/>
</LinearLayout>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</LinearLayout>
This gives us a three-row form: one row with a labeled field for the restaurant
name, one with a labeled field for the restaurant address, and a big Save button.
13
Step #3: Support All Screen Sizes
You may want to test this application on an emulator. You may want to test it on a
phone. You may want to test it on a tablet.
The layouts we use in these tutorials will work on a variety of screen sizes, but they
will work better if we tell Android that we do indeed those screen sizes. To that
end, we need to modify the manifest for our project, to add a <supports-screens>
element, declaring what sizes we support and do not.
Open the AndroidManifest.xml file in the root of your project tree, and add in a
<supports-screens> element. The resulting file should resemble:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial"
android:versionCode="l"
android:versionName="l.0">
<supports-screens
android:xlargeScreens="true
"
android:largeScreens="true"
android:normalScreens="true
"
android:smallScreens="false
"
/>
application android:label="(@string/app_name">
<activity android:name=".LunchList"
android:label="(@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Here, we are declaring that we support normal, large, and extra-large screens, but
not small screens. Android will not automatically scale down our UI, so our
application will not run on a small-screen device (typically under 3" diagonal
screen size). However, it will run well on everything bigger than that.
14
Step #4: Compile and Install the Application
Compile and install the application in the emulator by running the following
commands in your terminal:
ant clean install
Or, from Eclipse, just run the project.
Step #5: Run the Application in the Emulator
In your emulator, in the application launcher, you will see an icon for your
LunchList application. Click it to bring up your form:
Figure 6. The first edition of LunchList
Use the directional pad (D-pad) to navigate between the fields and button. Enter
some text in the fields and click the button, to see how those widgets behave.
Then, click the BACK button to return to the application launcher.
15
Step #6: Create a Model Class
Now, we want to add a class to the project that will hold onto individual
restaurants that will appear in the LunchList. Right now, we can only really work
with one restaurant, but that will change in a future tutorial.
So,
using
your
text
editor,
LunchList/src/apt/tutorial/Restaurant.java
create
a
new
file
with the following contents:
named
package apt.tutorial;
public class Restaurant {
private String name="";
private String address="";
public String getName() {
return(name);
}
public void setName(String name) {
this.name=name;
}
public String getAddress() {
return(address);
}
public void setAddress(String address) {
this.address=address;
}
}
This is simply a rudimentary model, with private data members for the name and
address, and getters and setters for each of those.
Of course, don't forget to save your changes!
Step #7: Save the Form to the Model
Finally, we want to hook up the Save button, such that when it is pressed, we
update a restaurant object based on the two EditText fields. To do this, open up
the LunchList/src/apt/tutorial/LunchList.java file and replace the generated
Activity implementation with the one shown below:
16
package apt.tutorial;
import
import
import
import
import
android.app.Activity;
android.os.Bundle;
android.view.View;
android.widget.Button;
android.widget.EditText;
public class LunchList extends Activity {
Restaurant r=new Restaurant();
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.main);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
EditText name=(EditText)findViewById(R.id.name);
EditText address=(EditText)findViewById(R.id.addr);
r.setName(name.getText().toString());
r.setAddress(address.getText().toString());
}
};
}
Here, we:
Create a single local restaurant instance when the activity is instantiated
Get our Button from the Activity via findViewById(), then connect it to a
listener to be notified when the button is clicked
In the listener, we get our two EditText widgets via findViewByid(), then
retrieve their contents and put them in the restaurant
This code sample shows the use of an anonymous inner class implementation of a
View.OnClickListener, named onSave. This technique is used in many places
throughout this book, as it is a convenient way to organize bits of custom code
that go into these various listener objects.
17
Then, run the ant install command to compile and update the emulator. Run the
application to make sure it seems like it runs without errors, though at this point
we are notreally using the data saved in the restaurant object just yet.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Instead of using the console tools as documented above, try using Eclipse.
You will need to download Eclipse, install the Android plug-in, and use it
to create your first project.
•
Try replacing the icon for yourapplication.To do this, you will need to find
a suitable 48x48 pixel image, create a drawable/ directory inside your res/
directory in the project, and adjust the AndroidManifest.xml file to contain
an android:icon = M@drawable/my_iconM attribute in the application element,
where my_icon is replaced by the base name of your image file.
•
Try playing with the fonts for use in both the TextView and EditText
widgets. The Android SDK documentation will show a number of XML
attributes you can manipulate to change the color, make the text boldface,
etc.
Further Reading
You can learn more about XML layouts in the "Using XML-Based Layouts" chapter
of The Busy Coder's Guide to Android Development. Similarly, you can learn more
about simple widgets, like fields and buttons, in the "Employing Basic Widgets"
chapter of the same book, where you will also find "Working w ith Containers" for
container classes like LinearLayout.
18
TUTORIAL 3
A Fancier Form
In this tutorial, we will switch to using a TableLayout for our restaurantdata entry
form, plus add a set of radio buttons to represent the type of restaurant.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 02-SimpleForm edition of
LunchList to use as a starting point.
Step #1: Switch to a TableLayout
First, open LunchList/res/layout/main.xml and modify its contents to look like the
following:
<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="Mfill_parent"
android:stretchColumns="1"
>
<TableRow>
<TextView android:text="Name/>
<EditText
android:id="M@+id/name" />
</TableRow>
<TableRow>
19
A Fancier Form
<TextView android:text="Address:" />
<EditText android:id="@+id/addr" />
</TableRow>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</TableLayout>
Notice that we replaced the three LinearLayout containers with a TableLayout and
two TableRow containers. We also set up the EditText column to be stretchable.
Recompile and reinstall the application, then run it in the emulator. You should
see something like this:
Figure 7. Using a TableLayout
Notice how the two EditText fields line up, whereas before, they appeared
immediately after each label.
20
NOTE: At this step, or any other, when you try to run your application, you may
get the following screen:
Figure 8. A "force-close" dialog
If you encounter this, first try to do a full rebuild of the project. In Eclipse, this
would involve doing Project > Force Clean. At the command line, use ant clean
or delete the contents of your bin/ and gen/ directories, then ant install. If the
problem persists after this, then there is a bug in your code somewhere. You can
use adb logcat, DDMS, or the DDMS perspective in Eclipse to see the Java stack
trace associated with this crash, to help you perhaps diagnose what is going on.
Step #2: Add a RadioGroup
Next, we should add some RadioButton widgets to indicate the type of restaurant
this is: one that offers take-out, one where we can sit down, or one that is only a
delivery service.
To do this, modify LunchList/res/layout/main.xml once again, this time to look like:
21
<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:stretchColumns="1"
>
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name" />
</TableRow>
<TableRow>
<TextView android:text="Address:" />
<EditText android:id="@+id/addr" />
</TableRow>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android:id="@+id/types">
<RadioButton android:id="@+id/take_out"
android:text="Take-Out"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroupp>
</TableRow>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</TableLayout>
Our RadioGroup and RadioButton widgets go inside the TableLayout, so they will line
up with the rest of table - you can see this once you recompile, reinstall, and run
the application:
22
Figure 9. Adding radio buttons
Step #3: Update the Model
Right now, our model class has no place to hold the restaurant type. To change
that, modify LunchList/src/apt/tutorial/Restaurant.java to add in a new private
String type data member and a getter/setter pair, like these:
public String getType() {
return(type);
}
public void setType(String type) {
this.type=type;
}
When you are done, your restaurant class should look something like this:
package apt.tutorial;
public class Restaurant {
private String name="";
private String address="";
23
private String type="";
public String getName() {
return(name);
}
public void setName(String name) {
this.name=name;
}
public String getAddress() {
return(address);
}
public void setAddress(String address) {
this.address=address;
}
public String getType() {
return(type);
}
public void setType(String type) {
this.type=type;
}
}
Step #4: Save the Type to the Model
Finally, we need to wire our RadioButton widgets to the model, such that when the
user clicks the Save button, the type is saved as well. To do this, modify the onSave
listener object to look like this:
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
EditText name=(EditText)findViewById(R.id.name);
EditText address=(EditText)findViewById(R.id.addr);
r.setName(name.getText().toString());
r.setAddress(address.getText().toString());
RadioGroup types=(RadioGroup)findViewById(R.id.types);
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
r.setType("sit_down");
break;
case R.id.take_out:
r.setType("take_out");
24
break;
case R.id.delivery:
r.setType("delivery");
break;
}
}
};
Note that you will also need to import android.widget.RadioGroup for this to
compile. The full activity will then look like this:
package apt.tutorial;
import
import
import
import
import
import
android.app.Activity;
android.os.Bundle;
android.view.View;
android.widget.Button;
android.widget.EditText;
android.widget.RadioGroup;
public class LunchList extends Activity {
Restaurant r=new Restaurant();
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.main);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
EditText name=(EditText)findViewById(R.id.name);
EditText address=(EditText)findViewById(R.id.addr);
r. setName(name.getText().toString());
r.setAddress(address.getText().toString());
RadioGroup types=(RadioGroup)findViewById(R.id.types);
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
r.setType("sit_down");
break;
case R.id.take_out:
r.setType("take_out");
break;
25
case R.id.delivery:
r.setType("delivery")
; break;
}
}
};
}
Recompile, reinstall, and run the application. Confirm that you can save the
restaurant data without errors.
If you are wondering what will happen if there is no selected RadioButton, the
RadioGroup call to getCheckedRadioButtonId() will return -1, which will not match
anything in our switch statement, and so the model will not be modified.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
If you have an Android device, try installing the app on the device and
running it there. The easiest way to do this is to shut down your emulator,
plug in your device, and run ant reinstall.
•
Set one of the three radio buttons to be selected by default, using
android:checked = "true".
•
Try creating the RadioButton widgets in Java code, instead of in the layout.
To do this, you will need to create the RadioButton objects themselves,
configure them (e.g., supply them with text to display), then add them to
the RadioGroup via addView() .
•
Tryadding more RadioButton widgets than there are room to display on the
screen. Note how the screen does not automatically scroll to show them.
Then, wrap your entire layout in a ScrollView container, and see how the
form can now scroll to accommodate all of your widgets.
26
Further Reading
You can learn more about radio buttons in the "Employing Basic Widgets" chapter
of The Busy Coder's Guide to Android Development. Also, you will find material on
TableLayout in the "Working with Containers" chapter of the same book.
27
28
TUTORIAL 4
Adding a List
In this tutorial, we will change our model to be a list of restaurants, rather than
just one. Then, we will add a ListView to view the available restaurants. This will be
rather incomplete, in that we can only add a new restaurant, not edit or delete an
existing one, but we will cover those steps too in a later tutorial.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 03-FancierForm edition of
LunchList to use as a starting point.
Step #1: Hold a List of Restaurants
First, if we are going to have a list of restaurants in the UI, we need a list of
restaurants as our model. So, in LunchList, change:
Restaurant r=new Restaurant();
to:
List<Restaurant> model=new ArrayList<Restaurant>();
29
Adding a List
Note that you will need to import java.util.List and java.util.ArrayList as well.
Step #2: Save Adds to List
Note that the above code will not compile, because our onSave Button click handler
is still set up to reference the old single restaurant model. For the time being, we
will have onSave simply add a new restaurant.
All we need to do is add a local restaurant r variable, populate it, and add it to the
list:
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
Restaurant r=new Restaurant();
EditText name=(EditText)findViewById(R.id.name);
EditText address=(EditText)findViewById(R.id.addr);
r.setName(name.getText().toString());
r.setAddress(address.getText().toString());
RadioGroup types=(RadioGroup)findViewById(R.id.types);
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
r.setType("sit_down");
break;
case R.id.take_out:
r.setType("take_out");
break;
case R.id.delivery:
r.setType("delivery");
break;
}
}
};
At this point, you should be able to rebuild and reinstall the application. Test it out
to make sure that clicking the button does not cause any unexpected errors.
30
Adding a List
You will note that we are not adding the actual restaurant to anything - r is a local
variable and so goes out of scope after onClick() returns. We will address this
shortcoming later in this exercise.
Step #3: Implement toString()
To simplify the creation of our ListView, we need to have our restaurant class
respond intelligently to toString(). That will be called on each restaurant as it is
displayed in our list.
For the purposes of this tutorial, we will simply use the name - later tutorials will
make the rows much more interesting and complex.
So, add a tostring() implementation on restaurant like this:
public String toString() {
return(getName());
}
Recompile and ensure your application still builds.
Step #4: Add a ListView Widget
Now comes the challenging part - adding the ListView to the layout.
The challenge is in getting the layout right. Right now, while we have only the one
screen to work with, we need to somehow squeeze in the list without eliminating
space for anything else. In fact, ideally, the list takes up all the available space that
is not being used by our current detail form.
One way to achieve that is to use a RelativeLayout as the over-arching layout for
the screen. We anchor the detail form to the bottom of the screen, then have the
list span the space from the top of the screen to the top of the detail form.
31
Adding a List
To make this change, replace your current LunchList/res/layout/main.xml with the
following:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TableLayout android:id="@+id/details"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:stretchColumns="1"
>
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name" />
</TableRow>
<TableRow>
<TextView android:text="Address:" />
<EditText android:id="@+id/addr" />
</TableRow>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android:id="@+id/types">
<RadioButton android:id="@+id/take_out"
android:text="Take-Out"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
</TableRow>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</TableLayout>
<ListView android:id="@+id/restaurants"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_above="@id/details"
/>
</RelativeLayout>
If you recompile and rebuild the application, then run it, you will see our form slid
to the bottom, with empty space at the top:
32
Adding a List
Figure 10. Adding a list to the top and sliding the form to the bottom
Step #5: Build and Attach the Adapter
The ListView will remain empty, of course, until we do something to populate it.
What we want is for the list to show our running lineup of restaurant objects.
Since we have our ArrayList<Restaurant>, we can easily wrap it in an
ArrayAdapter<Restaurant>. This also means, though, that when we add a restaurant,
we need to add it to the ArrayAdapter via add() - the adapter will, in turn, put it in
the ArrayList. Otherwise, if we add it straight to the ArrayList, the adapter will
not know about the added restaurant and therefore will not display it.
Here is the new implementation of the LunchList class:
package apt.tutorial;
import android.app.Activity;
33
Adding a List
import
import
import
import
import
import
import
import
import
android.os.Bundle;
android.view.View;
android.widget.ArrayAdapter;
android.widget.Button;
android.widget.EditText;
android.widget.ListView;
android.widget.RadioGroup;
java.util.ArrayList;
java.util.List;
public class LunchList extends Activity {
List<Restaurant> model=new ArrayList<Restaurant>();
ArrayAdapter<Restaurant> adapter=null;
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.main);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
ListView list=(ListView)findViewById(R.id.restaurants);
adapter=new ArrayAdapter<Restaurant>(this,
android.R.layout.simple_list_item_1, model);
list.setAdapter(adapter);
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
Restaurant r=new Restaurant();
EditText name=(EditText)findViewById(R.id.name);
EditText address=(EditText)findViewById(R.id.addr);
r.setName(name.getText().toString());
r.setAddress(address.getText().toString());
RadioGroup types=(RadioGroup)findViewById(R.id.types);
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
r.setType("sit_down");
break;
case R.id.take_out: r.setType("take_out");
break;
case R.id.delivery: r.setType("delivery");
break;
34
Adding a List
}
adapter.add(r);
}
};
}
The magic value android.R.layout.simple_list_item_1 is a stock layout for a list
row, just displaying the text of the object in white on a black background with a
reasonably large font. In later tutorials, we will change the look of our rows to suit
our own designs.
If you then add a few restaurants via the form, it will look something like this:
Figure 11. Our LunchList with a few fake restaurants added
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
35
Adding a List
See what the activity looks like if you use a Spinner instead of a ListView.
Make the address field, presently an EditText widget, into an
AutoCompleteTextView, using the other addresses as values to possibly reuse
(e.g., for multiple restaurants in one place, such as a food court or mall).
Further Reading
Information on ListView and other selection widgets can be found in the "Using
Selection Widgets" chapter of The Busy Coder's Guide to Android Development.
36
TUTORIAL 5
Making Our List Be Fancy
In this tutorial, we will update the layout of our ListView rows, so they show both
the name and address of the restaurant, plus an icon indicating the type. Along the
way, we will need to create our own custom ListAdapter to handle our row views
and a RestaurantHolder to populate a row from a restaurant.
Regarding the notion of adapters and ListAdapter, to quote from The Busy Coder's
Guide to Android Development:
In the abstract, adapters provide a common interface to multiple disparate
APIs. More specifically, in Android's case, adapters provide a common
interface to the data model behind a selection-style widget, such as a
listbox...Android's adapters are responsible for providing the roster of data
for a selection widget plus converting individual elements of data into
specific views to be displayed inside the selection widget.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 04-ListView edition of
LunchList to use as a starting point.
37
Making Our List Be Fancy
Step #1: Create a Stub Custom Adapter
First, let us create a stub implementation of a RestaurantAdapter that will be where
we put our logic for creating our own custom rows. That can look like this,
implemented as an inner class of LunchList:
class RestaurantAdapter extends ArrayAdapter<Restaurant> {
RestaurantAdapter() {
super(LunchList.this,
android.R.layout.simple_list_item_1,
model);
}
}
We hard-wire in the android.R.layout.simple_list_item_1 layout for now, and we
get our Activity and model from LunchList itself.
We also need to change our adapter data member to be a RestaurantAdapter, both
where it is declared and where it is instantiated in onCreate(). Make these
changes, then rebuild and reinstall the application and confirm it works as it did at
the end of the previous tutorial.
Step #2: Design Our Row
Next, we want to design a row that incorporates all three of our model elements:
name, address, and type. For the type, we will use three icons, one for each specific
type (sit down, take-out, delivery). You can use whatever icons you wish, oryou
canget the icons used in this tutorial from the tutorial ZIP file that you can
download. They need to be named ball_red.png, ball_yellow.png, and
ball_green.png, all located in res/drawable/ in your project.
NOTE: If your project has no res/drawable/ directory, but does have res/drawableldpi/ and others with similar suffixes, rename res/drawable-mdpi/ to res/drawable/
directory for use in this project, and delete theother res/drawable-* directories.
38
Making Our List Be Fancy
The general layout is to have the icon on the left and the name stacked atop the
address to the right:
Figure 12. A fancy row for our fancy list
To achieve this look, we use a nested pair of LinearLayout containers. Use the
following XML as the basis for LunchList/res/layout/row.xml:
<LinearLayout xmlns :android="http://schemas.android. com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:padding="4dip"
>
<ImageView android:id="@+id/icon"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:layout_alignParentTop="true"
android:layout_alignParentBottom="true"
android:layout_marginRight="4dip"
/>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="vertical"
>
<TextView android:id="@+id/title"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:gravity="center_vertical"
android:textStyle="bold"
android:singleLine="true"
android:ellipsize="end"
/>
<TextView android:id="@+id/address"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:gravity="center_vertical"
android:singleLine="true"
android:ellipsize="end"
/>
</LinearLayout>
</LinearLayout>
39
Making Our List Be Fancy
Some of the unusual attributes applied in this layout include:
•
android:padding,
which arranges for some whitespace to be put outside
the actual widget contents but still be considered part of the widget (or
container) itself when calculating its size
•
android:textStyle,
where we can indicate that some text is in bold or
italics
•
android:singleLine,
which, if true, indicates that text should not wordwrap if it extends past one line
•
android:ellipsize,
which indicates where text should be truncated and
ellipsized if it is too long for the available space
Step #3: Override getView(): The Simple Way
Next, we need to use this layout ourselves in our RestaurantAdapter. To do this, we
need to override getView() and inflate the layout as needed for rows.
Modify RestaurantAdapter to look like the following:
class RestaurantAdapter extends ArrayAdapter<Restaurant> {
RestaurantAdapter() {
super(LunchList.this,
android.R.layout.simple_list_item_1,
model);
}
public View getView(int position, View convertView,
ViewGroup parent) {
View row=convertView;
if (row==null) {
Layoutlnflater inflater=getLayoutInflater();
row=inflater.inflate(R.layout.row, null);
}
Restaurant r=model.get(position);
((TextView)row.findViewById(R.id.title)).setText(r.getName());
((TextView)row.findViewById(R.id.address)).setText(r.getAddress());
ImageView icon=(ImageView)row.findViewById(R.id.icon);
40
Making Our List Be Fancy
if (r.getType().equals("sit_down")) {
icon.setImageResource(R.drawable.ball_red);
}
else if (r.getType().equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon.setImageResource(R.drawable.ball_green);
}
return(row);
}
}
Notice how we create a row only if needed, recycling existing rows. But, we still
pick out each TextView and imageView from each row and populate it from the
restaurant at the indicated position.
Step #4: Create a RestaurantHolder
To improve performance and encapsulation, we should move the logic that
populates a row from a restaurant into a separate class, one that can cache the
TextView and ImageView widgets.
To do this, add the following static inner class to LunchList:
static class RestaurantHolder {
private TextView name=null;
private TextView address=null;
private ImageView icon=null;
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Restaurant r) {
name.setText(r.getName());
address.setText(r.getAddress());
if (r.getType().equals("sit_down")) {
icon.setImageResource(R.drawable.ball_red);
}
else if (r.getType().equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
41
}
else {
icon.setImageResource(R.drawable.ball_green);
}
}
}
Step #5: Recycle Rows via RestaurantHolder
To take advantage of the new RestaurantHolder, we need to modify getView() in
RestaurantAdapter. Following the holder pattern, we need to createa
RestaurantHolder whenwe inflatea new row, cache thatwrapper in the row
via setTag(), then get it back later via getTag().
Change getView() to look like the following:
public View getView(int position, View convertView,
ViewGroup parent) {
View row=convertView;
RestaurantHolder holder=null;
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(R.layout.row, parent, false);
holder=new RestaurantHolder(row);
row.setTag(holder);
}
else {
holder=(RestaurantHolder)row.getTag();
}
holder.populateFrom(model.get(position));
return(row);
}
This means the whole LunchList class looks like:
package apt.tutorial;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;
import android.view.LayoutInflater;
import android.widget.ArrayAdapter;
42
Making Our List Be Fancy
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.RadioGroup; import
android.widget.TextView;
import java.util.ArrayList;
import java.util.List;
public class LunchList extends Activity {
List<Restaurant> model=new ArrayList<Restaurant>();
RestaurantAdapter adapter=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); setContentView(R.layout.main);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
ListView list=(ListView)findViewById(R.id.restaurants);
adapter=new RestaurantAdapter();
list.setAdapter(adapter);
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
Restaurant r=new Restaurant();
EditText name=(EditText)findViewById(R.id.name);
EditText address=(EditText)findViewById(R.id.addr);
r.setName(name.getText().toString());
r.setAddress(address.getText().toString());
RadioGroup types=(RadioGroup)findViewById(R.id.types);
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
r.setType("sit_down");
break;
case R.id.take_out:
r.setType("take_out");
break;
case R.id.delivery:
r.setType("delivery");
break;
}
adapter.add(r);
43
Making Our List Be Fancy
}
};
class RestaurantAdapter extends ArrayAdapter<Restaurant> {
RestaurantAdapter() {
super(LunchList.this, R.layout.row, model);
}
public View getView(int position, View convertView, ViewGroup parent) {
View row=convertView;
RestaurantHolder holder=null;
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(R.layout.row, parent, false);
holder=new RestaurantHolder(row); row.setTag(holder);
}
else {
holder=(RestaurantHolder)row.getTag();
}
holder.populateFrom(model.get(position));
return(row);
}
}
static class RestaurantHolder {
private TextView name=null;
private TextView address=null;
private ImageView icon=null;
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Restaurant r) { name.setText(r.getName());
address.setText(r.getAddress());
if (r.getType().equals("sit_downM)) {
icon.setImageResource(R.drawable.ball_red);
}
else if (r.getType().equals("take_outM)) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon.setImageResource(R.drawable.ball_green);
}
44
Making Our List Be Fancy
}
}
}
Rebuild and reinstall the application, then try adding several restaurants and
confirm that, when the list is scrolled, everything appears as it should -the name,
address, and icon all change.
Note that you may experience a problem, where your EditText widgets shrink,
failing to follow the android:stretchColumns rule. This is a bug in Android that will
hopefully be repaired one day.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Customize the rows beyond just the icon based on each restaurant, such
as applying different colors to the name based upon certain criteria.
•
Use three different layouts for the three different restaurant types. To do
this, you will need to override getitemViewType() and getViewTypeCount() in
the custom adapter to return the appropriate data.
Further Reading
Using custom Adapter classes and creating list rows that are more than mere
strings is covered in the "Getting Fancy with Lists" chapter of The Busy Coder's
Guide to Android Development.
45
46
TUTORIAL 6
Splitting the Tab
In this tutorial, we will move our ListView onto one tab and our form onto a
separate tab of a TabView. Along the way, we will also arrange to update our form
based on a ListView selections or clicks, even though the Save button will still only
add new restaurants to our list.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 05-FancyList edition of
LunchList to use as a starting point.
Step #1: Rework the Layout
First, we need to change our layout around, to introduce the tabs and split our UI
between a list tab and a details tab. This involves:
•
Removing the RelativeLayout and the layout attributes leveraging it, as
that was how we had the list and form on a single screen
•
Add in a TabHost, TabWidget, and FrameLayout, the latter of which is parent
to the list and details
To accomplish this, replace your current LunchList/res/layout/main.xml with the
following:
47
Splitting the Tab
<?xml version="1.0" encoding="utf-8"?>
<TabHost xmlns:android=”http://schemas.android.com/apk/res/android”
android:id="@android:id/tabhost"
android:layout_width= "fill_parent"
android:layout_height="fill_parent">
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TabWidget android:id="@android:id/tabs"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
/>
<FrameLayout android:id="@android:id/tabconten"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<ListView android:id="@+id/restaurants"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
/>
<TableLayout android:id="@+id/details"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="1"
android:paddingTop="4dip" >
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name" />
</TableRow>
<TableRow>
<TextView android:text="Address:" />
<EditText android:id="@+id/addr" />
</TableRow>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android:id="@+id/types">
<RadioButton android:id=M@+id/take_outM
android:text="Take-Out"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
</TableRow>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
48
Splitting the Tab
</TableLayout>
</FrameLayout>
</LinearLayout>
</TabHost>
Step #2: Wire In the Tabs
Next, we need to modify the LunchList itself, so it is a TabActivity (rather than a
plain Activity) and teaches the TabHost how to use our FrameLayout contents for
the individual tab panes.To do this:
1.
Add
imports
to
LunchList
for
android.app.TabActivity
and
android.widget.TabHost
2.
Make LunchList extend TabActivity
3.
Obtain 32px high icons from some source to use for the list and details tab
icons, place them in LunchList/res/drawable as list.png and
restaurant.png, respectively
4. Add the following code to the end of your onCreate() method:
TabHost.TabSpec spec=getTabHost().newTabSpec("tagl");
spec.setContent(R.id.restaurants);
spec.setIndicator("List", getResources()
.getDrawable(R.drawable.list));
getTabHost().addTab(spec);
spec=getTabHost().newTabSpec("tag2");
spec.setContent(R.id.details);
spec.setIndicator("Details", getResources()
.getDrawable(R.drawable.restaurant));
getTabHost().addTab(spec);
getTabHost().setCurrentTab(0);
At this point, you can recompile and reinstall the application and try itout. You
should see a two-tab UI like this:
49
Splitting the Tab
Figure 13. The first tab of the two-tab LunchList
Figure 14. The second tab of the two-tab LunchList
50
Splitting the Tab
Step #3: Get Control On List Events
Next, we need to detect when the user clicks on one of our restaurants in the list,
so we can update our detail form with that information.
First, add an import for android.widget.AdapterView to LunchList. Then, create an
AdapterView.OnltemClickListener named onListClick:
private
AdapterView.OnltemClickListener
onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position,
long id) {
}
};
Finally, call setOnItemClickListener() on the ListView in the activity's onCreate() to
connect
the
ListView
to
the
onListClick
listener
object
(list.setOnltemClickListener(onListClick);)
Step #4: Update Our Restaurant Form On Clicks
Next, now that we have control in a list item click, we need to actually find the
associated restaurant and update our details form.
To do this, you need to do two things. First, move the name, address, and types
variables into data members and populate them in the activity's onCreate() - our
current code has them as local variables in the onSave listener object's onClick()
method. So, you should have some data members
like:
EditText name=null;
EditText
address=null;
RadioGroup
types=null;
And some code after the call to setContentView() in onCreate() like:
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
types=(RadioGroup)findViewById(R.id.types);
51
Splitting the Tab
Then, add smarts to onListClick to update the details form:
Private
AdapterView.OnltemClickListener
onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position,
long id) {
Restaurant r=model.get(position);
name.setText(r.getName());
address.setText(r.getAddress());
if (r.getType().equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (r.getType().equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
}
};
Note how we find the clicked-upon restaurant via the position parameter, which is
an index into our ArrayList ofrestaurants.
Step #5: Switch Tabs On Clicks
Finally, we want to switch to the detail form when the user clicks a restaurant in
the list.
This is just one extra line of code, in the onItemClick() method of our onListClick
listener object:
getTabHost().setCurrentTab(l);
This just changes the current tab to the one known as index l, which is the second
tab (tabs start counting at 0).
At this point, you should be able to recompile and reinstall the application and test
out the new functionality.
52
Splitting the Tab
Here is the complete source code to our LunchList activity, after all of the changes
made in this tutorial:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
android.app.TabActivity;
android.os.Bundle;
android.view.View;
android.view.ViewGroup;
android.view.LayoutInflater;
android.widget.AdapterView;
android.widget.ArrayAdapter;
android.widget.Button;
android.widget.EditText;
android.widget.ImageView;
android.widget.ListView;
android.widget.RadioGroup;
android.widget.TabHost;
android.widget.TextView;
java.util.ArrayList;
java.util.List;
public class LunchList extends TabActivity {
List<Restaurant> model=new ArrayList<Restaurant>();
RestaurantAdapter adapter=null;
EditText name=null;
EditText address=null;
RadioGroup types=null;
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.main);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
types=(RadioGroup)findViewById(R.id.types);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
ListView list=(ListView)findViewById(R.id.restaurants);
adapter=new RestaurantAdapter();
list.setAdapter(adapter);
TabHost.TabSpec spec=getTabHost().newTabSpec("tagl");
spec.setContent(R.id.restaurants);
spec.setIndicator("List", getResources()
.getDrawable(R.drawable.list));
getTabHost().addTab(spec);
53
Splitting the Tab
spec=getTabHost().newTabSpec("tag2");
spec.setContent(R.id.details);
spec.setIndicator("Details", getResources()
.getDrawable(R.drawable.restaurant));
getTabHost().addTab(spec);
getTabHost().setCurrentTab(0);
list.setOnItemClickListener(onListClick);
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) { Restaurant r=new Restaurant();
r.setName(name.getText().toString());
r.setAddress(address.getText().toString());
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
r.setType(“sit_down”);
break;
case R.id.take_out:
r.setType("take_out");
break;
case R.id.delivery:
r.setType("delivery");
break;
}
adapter.add(r);
}
};
private AdapterView.OnltemClickListener onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position,
long id) {
Restaurant r=model.get(position);
name.setText(r.getName());
address.setText(r.getAddress());
if (r.getType().equals("sit_down")) {
types.check(R.id.sitdown);
}
else if (r.getType().equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
54
Splitting the Tab
getTabHost().setCurrentTab(l);
}
};
class RestaurantAdapter extends ArrayAdapter<Restaurant> {
RestaurantAdapter() {
super(LunchList.this, R.layout.row, model);
}
public View getView(int position, View convertView, ViewGroup
parent) { View row=convertView;
RestaurantHolder holder=null;
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(R.layout.row, parent, false);
holder=new RestaurantHolder(row);
row.setTag(holder);
}
else {
holder=(RestaurantHolder)row.getTag();
}
holder.populateFrom(model.get(position));
return(row);
}
}
static class RestaurantHolder {
private TextView name=null;
private TextView address=null;
private ImageView icon=null;
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Restaurant r) {
name.setText(r.getName());
address.setText(r.getAddress());
if (r.getType().equals("sit_down")) {
icon.setImageResource(R.drawable.ball_red);
}
else if (r.getType().equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon setImageResource(R.drawable.ball green);
55
Splitting the Tab
}
}
}
}
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Add a date in the restaurant model to note the last time you visited the
restaurant, then use either DatePicker or DatePickerDialog to allow users to
set the date when they create their restaurant objects.
•
Try making a version of the activity that uses a ViewFlipper and a Button to
flip from the list to the detail form, rather than using two tabs.
Further Reading
The use of tabs in an Android activity is covered in the "Still More Widgets and
Containers" chapter of The Busy Coder's Guide to Android Development.
56
TUTORIAL 7
Menus and Messages
In this tutorial, we will add an EditText for a note to our detail form and restaurant
model. Then, we will add an options menu that will display the note as a Toast.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 06-Tabs edition of
LunchList to use as a starting point.
Step #1: Add Notes to the Restaurant
First, our restaurant model does not have any spot for notes. Add a String notes
data member plus an associated getter and setter. Your resulting class should look
like:
package apt.tutorial;
public class Restaurant {
private String name="";
private String address="";
private String type="";
private String
notes="";public String
getName() { return(name);
57
Menus and Messages
}
public void setName(String name) {
this.name=name;
}
public String getAddress() {
return(address);
}
public void setAddress(String address) {
this.address=address;
}
public String getType() {
return(type);
}
public void setType(String type) {
this.type=type;
}
public String getNotes() {
return(notes);
}
public void setNotes(String notes) {
this.notes=notes;
}
public String toString() {
return(getName());
}
}
Step #2: Add Notes to the Detail Form
Next, we need LunchList to make use of the notes. To do this, first add the
following TableRow above the Save button in our TableLayout in
LunchList/res/layout/main.xml:
<TableRow>
<TextView android:text="Notes:" />
<EditText android:id="@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="2"
android:scrollHorizontally="false"
android:maxLines="2"
android:maxWidth="200sp"
58
Menus and Messages
/>
</TableRow>
Then, we need to modify the LunchList activity itself, by:
1.
Adding another data member for the notes EditText widget defined above
2.
Find our notes EditText widget as part of onCreate(), like we do with
other EditText widgets
3.
Save our notes to our restaurant in onSave
4.
Restore our notes to the EditText in onListClick
At this point, you can recompile and reinstall the application to see your notes
field in action:
Figure 15. The notes field in the detail form
59
Menus and Messages
Step #3: Define the Option Menu
Now, we need to create an options menu and arrange for it to be displayed when
the user clicks the [MENU] button.
The menu itself can be defined as a small piece ofXML. Enter the following as
LunchList/res/menu/option.xml:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/toast"
android:title="Raise Toast"
android:icon="@drawable/toast"
/>
</men
u>
This code relies upon an icon stored in LunchList/res/drawable/toast.png. Find
something suitable to use, preferably around 32px high.
Then, to arrange for the menu to be displayed, add the following method to
LunchList:
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.option, menu);
return(super.onCreateOptionsMenu(menu));
}
Note that you will also need to define imports for android.view.Menu and
android.view.Menulnflater for this to compile cleanly.
At this point, you can rebuild and reinstall the application. Click the [MENU]
button, from either tab, to see the options menu with its icon:
60
Menus and Messages
Figure 16. The LunchList options menu, displayed, with one menu choice
Step #4: Show the Notes as a Toast
Finally, we need to get control when the user selects the Raise Toast menu choice
and display the notes in a Toast.
The problem is that, to do this, we need to know what restaurant to show. So far,
we have not been holdingonto a specific restaurant except when we needed it,
such as when we populate the detail form. Now, we need to know our current
restaurant, defined as the one visible in the detail form...which could be none, if
we have not yet saved anything in the form.
To make all of this work, do the following:
1.
Add another data member, restaurant current, to hold the current
restaurant. Be sure to initialize it to null.
2.
In onSave and onListClick, rather than declaring local restaurant variables,
use current to hold the restaurant we are saving (in
61
Menus and Messages
or have clicked on (in onListClick). You will need to change all
references to the old r variable to be current in these two objects.
onSave)
Add imports for android.view.Menultem and android.widget.Toast.
3.
4. Add the following implementation of onOptionsItemSelected() to your
LunchList class:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.toast) {
String message="No restaurant selected";
if (current!=null) {
message=current.getNotes();
}
Toast.makeText(this,message,Toast.LENGTH_LONG).show();
return(true);
}
return(super.onOptionsItemSelected(item));
}
Note how we will either display "No restaurant selected" (if current is null) or the
restaurant's notes, depending on our current state.
You can now rebuild and reinstall the application. Enter and save a restaurant,
with notes, then choose the RaiseToast options menu item, and you will briefly see
your notes in a Toast:
62
Menus and Messages
Figure 17. The Toast displayed, with some notes
The LunchList activity, as a whole, is shown below, incorporating all of the changes
outlined in this tutorial:
package apt.tutorial;
import android.app.TabActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.Menulnflater;
import android.view.Menultem;
import android.view.View;
import android.view.ViewGroup;
import android.view.LayoutInflater;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.RadioGroup;
import android.widget.TabHost;
import android.widget.TextView;
import android.widget.Toast;
import Java.util.ArrayList;
import lava.util.List;
63
Menus and Messages
public class LunchList extends TabActivity {
List<Restaurant> model=new ArrayList<Restaurant>();
RestaurantAdapter adapter=null;
EditText name=null;
EditText address=null;
EditText notes=null;
RadioGroup types=null;
Restaurant current=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
ListView list=(ListView)findViewById(R.id.restaurants);
adapter=new RestaurantAdapter();
list.setAdapter(adapter);
TabHost.TabSpec spec=getTabHost().newTabSpec("tagl");
spec.setContent(R.id.restaurants);
spec.setIndicator("List", getResources()
.getDrawable(R.drawable.list));
getTabHost().addTab(spec);
spec=getTabHost().newTabSpec("tag2");
spec.setContent(R.id.details);
spec.setIndicator("Details", getResources()
.getDrawable(R.drawable.restaurant));
getTabHost().addTab(spec);
getTabHost().setCurrentTab(0);
list.setOnItemClickListener(onListClick);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.option, menu);
return(super.onCreateOptionsMenu(menu));
}
@Override
64
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.toast) {
String message="No restaurant selected";
if (current!=null) {
message=current.getNotes();
}
Toast.makeText(this, message, Toast.LENGTHLONG).show();
return(true);
}
return(super.onOptionsItemSelected(item));
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
current=new Restaurant();
current.setName(name.getText().toString());
current.setAddress(address.getText().toString());
current.setNotes(notes.getText().toString());
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
current.setType("sit_down");
break;
case R.id.take_out:
current.setType("take_out");
break;
case R.id.delivery:
current.setType("delivery");
break;
}
adapter.add(current);
}
};
private AdapterView.OnItemClickListener onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position,
long id) {
current=model.get(position);
name.setText(current.getName());
address.setText(current.getAddress());
notes.setText(current.getNotes());
if (current.getType().equals("sit_down")) {
types.check(R.id.sitdown);
}
65
else if (current.getType().equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
getTabHost().setCurrentTab(l);
}
};
class RestaurantAdapter extends ArrayAdapter<Restaurant> {
RestaurantAdapter() {
super(LunchList.this, R.layout.row, model);
}
public View getView(int position, View convertView, ViewGroup
parent) { View row=convertView;
RestaurantHolder holder=null;
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(R.layout.row, parent, false);
holder=new RestaurantHolder(row);
row.setTag(holder);
}
else {
holder=(RestaurantHolder)row.getTag();
}
holder.populateFrom(model.get(position));
return(row);
}
}
static class RestaurantHolder {
private TextView name=null;
private TextView address=null;
private ImageView icon=null;
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Restaurant r) {
name.setText(r.getName());
address.setText(r.getAddress());
if (r.getType().equals("sit_down")) {
icon.setImageResource(R.drawable.ball red);
66
Menus and Messages
}
else if (r.getType().equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon.setImageResource(R.drawable.ball_green);
}
}
}
}
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Try using an AlertDialog instead of a Toast to display the message.
•
Try adding a menu option to switch you between tabs. In particular,
change the text and icon on the menu option to reflect the other tab (i.e.,
on the List tab, the menu should show "Details" and the details tab icon;
on the Details tab, the menu should show "List" and the List tab icon).
•
Try creating an ErrorDialog designed to display exceptions in a "pleasant"
format to the end user. The ErrorDialog should also log the exceptions via
android.util.Log. Use some sort of runtime exception (e.g., division by
zero) for generating exceptions to pass to the dialog.
Further Reading
You can learn more about menus - both options menus and context menus - in the
"Applying Menus" chapter of The Busy Coder's Guide to Android Development.
The use of a Toast is covered in the "Showing Pop-Up Messages" chapter of the
same book.
67
68
TUTORIAL 8
Sitting in the Background
In this tutorial, we will simulate having the LunchList do some background
processing in a secondary thread, updating the user interface via a progress bar.
While all of these tutorials are somewhat contrived, this one will be more
contrived than most, as there is not much we are really able to do in a LunchList
that would even require long processing in a background thread. So, please forgive
us if this tutorial is a bit goofy.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 07-MenusMessages edition of
LunchList to use as a starting point.
Step #1: Initialize the Progress Bar
For this application, rather than use a ProgressBar widget, we will use the progress
bar feature of the Activity window. This will put a progress bar in the title bar,
rather than clutter up our layouts.
This requires a bit of initialization. Specifically, we need to add a line to onCreate()
that will request this feature be activated. We have to do this before calling
setContentView(), so we add it right after chaining to the superclass:
69
Sitting in the Background
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
requestWindowFeature(Window.FEATURE_PROGRESS);
setContentView(R.layout.main);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
ListView list=(ListView)findViewById(R.id.restaurants);
adapter=new RestaurantAdapter();
list.setAdapter(adapter);
TabHost.TabSpec spec=getTabHost().newTabSpec("tagl");
spec.setContent(R.id.restaurants);
spec.setIndicator("List", getResources()
.getDrawable(R.drawable.list));
getTabHost().addTab(spec);
spec=getTabHost().newTabSpec("tag2");
spec.setContent(R.id.details);
spec.setIndicator("Details", getResources()
.getDrawable(R.drawable.restaurant));
getTabHost().addTab(spec);
getTabHost().setCurrentTab(0);
list.setOnItemClickListener(onListClick);
}
Also, add another data member, an int named progress.
Step #2: Create the Work Method
The theory of this demo is that we have something that takes a long time, and we
want to have that work done in a background thread and update the progress
along theway. So, the firststep is to build something thatwill run a long time.
70
Sitting in the Background
To do that, first, implement a doSomeLongWork() method on LunchList as follows:
private void doSomeLongWork(final int incr) {
SystemClock.sleep(250);
// should be something more useful!
}
Here, we sleep for 250 milliseconds, simulating doing some meaningful work.
Then, create a private Runnable in LunchList that will fire off doSomeLongWork() a
number of times, as follows:
private Runnable longTask=new Runnable() {
public void run() {
for (int i=0;i<20;i++) {
doSomeLongWork(500);
}
}
};
Here, we just loop 20 times, so the overall background thread will run for 5
seconds.
Step #3: Fork the Thread from the Menu
Next, we need to arrange to do this (fake) long work at some point. The easiest way
to do that is add another menu choice. Update the LunchList/res/menu/option.xml
file to look like the following:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/toast"
android:title="Raise Toast"
android:icon="@drawable/toast"
/>
<item android:id="@+id/run"
android:title="Run Long Task"
android:icon="@drawable/run"
/>
</menu
>
71
Sitting in the Background
This requires a graphic image in LunchList/res/drawable/run.png - find something
that you can use that is around 32px high.
Since the menu item is in the menu XML, we do not need to do anything special to
display the item - it will just be added to the menu automatically. We do, however,
need to arrange to do something useful when the menu choice is chosen. So,
update onOptionsItemSelected() in LunchList to look like the following:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.toast) {
String message="No restaurant selected";
if (current!=null) {
message=current.getNotes();
}
Toast.makeText(this,message,Toast.LENGTH_LONG).show();
return(true);
}
else if (item.getItemId()==R.id.run) {
new Thread(longTask).start();
}
return(super.onOptionsItemSelected(item));
}
You are welcome to recompile, reinstall, and run the application. However, since
our background thread does not do anything visible at the moment, all you will see
that is different is the new menu item:
72
Sitting in the Background
Figure 18. The Run Long Task menu item
Step #4: Manage the Progress Bar
Finally, we need to actually make use of the progress indicator. This involves
making it visible when we start our long-running task, updating it as the task
proceeds, and hiding it again when the task is complete.
First, make it visible by updating onOptionsItemSelected() to show it:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.toast) {
String message="No restaurant selected";
if (current!=null) {
message=current.getNotes();
}
Toast.makeText(this, message, Toast.LENGTHLONG).show();
return(true);
}
else if (item.getItemId()==R.id.run) {
73
Sitting in the Background
setProgressBarVisibility(true);
progress=0;
new Thread(longTask).start();
return(true);
}
return(super.onOptionsItemSelected(item));
}
Notice the extra line that makes progress visible.
Then, we need to update the progress bar on each pass, so make this change to
doSomeLongWork():
private void doSomeLongWork(final int incr) {
runOnUiThread(new Runnable() {
public void run() {
progress+=incr;
setProgress(progress);
}
});
SystemClock.sleep(250);
// should be something more useful!
}
Notice how we use runOnuiThread() to make sure our progress bar update occurs
on the UI thread.
Finally, we need to hide the progress bar when we are done, so make this change
to our longTask Runnable:
private Runnable longTask=new Runnable() {
public void run() {
for (int i=0;i<20;i++) {
doSomeLongWork(500);
}
runOnUiThread(new Runnable() {
public void run() {
setProgressBarVisibility(false);
}
});
}
74
Sitting in the Background
At this point, you can rebuild, reinstall, and run the application. When you choose
the Run Long Task menu item, you will see the progress bar appear for five
seconds, progressively updated as the "work" gets done:
Figure 19. The progress bar in action
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Have the background thread also update some UI element when the work
is completed, beyond dismissing the progress bar. Make sure you arrange
to update the UI on the UI thread!
•
Instead of using Activity#runOnUiThread(), try using a Handler for
communication between the background thread and the UI thread.
•
Instead of starting a Thread from the menu choice, have the Thread be
created in onCreate() and have it monitor a LinkedBlockingQueue (from
java. util. concurrent) as a source of work to be done. Create a FakeJob
that does what our current long-running method does, and
75
Sitting in the Background
a KillJob that causes the Thread to fall out of its queue-monitoring loop.
Further Reading
Coverage of the Android concept of "the UI thread" and tools like the Handler for
managing communication between threads can be found in the "Dealing with
Threads" chapter of The Busy Coder's Guide to Android Development. You will
also learn about AsyncTask in that chapter, which is another important means of
coordinating background and UI thread operations.
If you are interested in Java threading in general, particularly the use of the
java.util.concurrent set of thread-management classes, the book Java
Concurrency in Practice is a popular source of information.
76
TUTORIAL 9
Life and Times
In this tutorial, we will make our background task take a bit longer, then arrange
to pause the background work when we start up another activity and restart the
background work when our activity regains control. This pattern - stopping
unnecessary background work when the activity is paused - is a good design
pattern and is not merely something used for a tutorial.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 08-Threads edition of
LunchList to use as a starting point.
Step #1: Lengthen the Background Work
First, let us make the background work take a bit longer, so we have a bigger
"window" in which to test whether our pause-and-resume logic works. It is also
helpful, in our case, to synchronize our loop with our progress, so rather than
counting 0 to 20 by 1, we should count from 0 to 10000 by 200, so the loop
counter and progress are the same.
In the longTask Runnable, change the loop to look like this:
77
Life and Times
for (int i=progress;
i<10000;
i+=200) {
doSomeLongWork(200)
;
}
Step #2: Pause in onPause()
Now, we need to arrange to have our thread stop running when the activity is
paused (e.g., some other activity has taken over the screen). Since threads are
relatively cheap to create and destroy, we can simply have our current running
thread stop and start a fresh one, if needed, in onResume().
While there are some deprecated methods on Thread to try to forcibly terminate
them, it is generally better to let the Thread stop itself by falling out of whatever
processing loop it is in. So, what we want to do is let the background thread know
the activity is not active.
To do this, first import java.util.concurrent.atomic.AtomicBoolean in LunchList and
add an AtomicBoolean data member named isActive , initially set to true (new
AtomicBoolean(true);).
Then, in the longTask Runnable, change the loop to also watch for the state of
isActive, falling out of the loop if the activity is no longer active:
for (int i=progress;
i<10000 && isActive.get();
i+=200) {
doSomeLongWork(200);
}
Finally, implement onPause() to update the state of isActive:
@Override
public void onPause() {
super.onPause();
isActive.set(false);
}
78
Life and Times
Note how we chain to the superclass in onPause() - if we fail to do this, we will get
a runtime error.
With this implementation, our background thread will run to completion or until
isActive is false, whichever comes first.
Step #3: Resume in onResume()
Now, we need to restart our thread if it is needed. It will be needed if the progress
is greater than 0, indicating we were in the middle of our background work when
our activity was so rudely interrupted.
So, add the following implementation of onResume():
@Override
public void onResume() {
super.onResume();
isActive.set(true);
if (progress>0) {
startWork();
}
}
This assumes we have pulled out our thread-starting logic into a startWork()
method, which you should implement as follows:
private void startWork() {
setProgressBarVisibility(true);
new Thread(longTask).start();
}
And you can change our menu handler to also use startwork():
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.toast) {
String message="No restaurant selected";
if (current!=null) {
message=current.getNotes();
}
79
Life and Times
Toast.makeText(this,message,Toast.LENGTH_LONG).show();
return(true);
}
else if (item.getItemId()==R.id.run) {
startWork();
return(true);
}
return(super.onOptionsItemSelected(item));
}
Finally, we need to not reset and hide the progress indicator when our background
thread ends if it ends because our activity is not active. Otherwise, we will never
restart it, since the progress will be reset to 0 every time. So, change longTask one
more time, to look like this:
private Runnable longTask=new Runnable() {
public void run() {
for (int i=progress;
i<10000 && isActive.get();
i+=200) {
doSomeLongWork(200);
}
if (isActive.get()) {
runOnUiThread(new Runnable() {
public void run() {
setProgressBarVisibility(false);
progress=0;
}
});
}
}
What this does is reset the progress only if we are active when the work is
complete, so we are ready for the next round of work. If we are inactive, and fell
out of our loop for that reason, we leave the progress as-is.
At this point, recompile and reinstall the application. To test this feature:
1. Use the [MENU] button to run the long task.
80
Life and Times
2.
While it is running, click the green phone button on the emulator (lowerleft corner of the "phone"). This will bring up the call log activity and, as a
result, pause our LunchList activity.
3.
After a while, click the BACK button - you should see the LunchList
resuming the background work from the point where it left off.
Here is the full LunchList implementation, including the changes shown above:
package apt.tutorial;
import android.app.TabActivity;
import android.os.Bundle;
import android.os.SystemClock;
import android.view.Menu;
import android.view.Menulnflater;
import android.view.Menultem;
import android.view.View;
import android.view.ViewGroup;
import android.view.LayoutInflater;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.RadioGroup;
import android.widget.TabHost;
import android.widget.TextView;
import android.widget.Toast;
import Java.util.ArrayList;
import Java.util.List;
import Java.util.concurrent.atomic.AtomicBoolean;
public class LunchList extends TabActivity {
List<Restaurant> model=new ArrayList<Restaurant>();
RestaurantAdapter adapter=null;
EditText name=null;
EditText address=null;
EditText notes=null;
RadioGroup types=null;
Restaurant current=null;
AtomicBoolean isActive=new AtomicBoolean(true);
int progress=0;
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
requestWindowFeature(Window.FEATURE_PROGRESS);
81
Life and Times
setContentView(R.layout.main);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
ListView list=(ListView)findViewById(R.id.restaurants);
adapter=new RestaurantAdapter();
list.setAdapter(adapter);
TabHost.TabSpec spec=getTabHost().newTabSpec("tagl");
spec.setContent(R.id.restaurants);
spec.setIndicator("List", getResources()
.getDrawable(R.drawable.list));
getTabHost().addTab(spec);
spec=getTabHost().newTabSpec("tag2");
spec.setContent(R.id.details);
spec.setIndicator("Details", getResources()
.getDrawable(R.drawable.restaurant));
getTabHost().addTab(spec);
getTabHost().setCurrentTab(0);
list.setOnItemClickListener(onListClick);
}
@Override
public void onPause() {
super.onPause();
isActive.set(false);
}
@Override
public void onResume() {
super.onResume();
isActive.set(true);
if (progress>0)
{
startWork();
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.option, menu);
82
Life and Times
return(super.onCreateOptionsMenu(menu));
}
@Override
public boolean onOptionsItemSelected(MenuItem item) { if
(item.getItemId()==R.id.toast) {
String message="No restaurant selected";
if (current!=null) {
message=current.getNotes();
}
Toast.makeText(this, message, Toast.LENGTH_LONG).show();
return(true);
}
else if (item.getItemId()==R.id.run) {
startWork();
return(true);
}
return(super.onOptionsItemSelected(item));
}
private void startWork() {
setProgressBarVisibility(true);
new Thread(longTask).start();
}
private void doSomeLongWork(final int incr) {
runOnUiThread(new Runnable() {
public void run() {
progress+=incr;
setProgress(progress);
}
});
SystemClock.sleep(250);
// should be something more useful!
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
current=new Restaurant();
current.setName(name.getText().toString());
current.setAddress(address.getText().toString());
current.setNotes(notes.getText().toString());
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
current.setType("sit_down");
break;
case R.id.take_out:
83
Life and Times
current.setType("take_out");
break;
case R.id.delivery:
current.setType("delivery");
break;
}
adapter.add(current);
}
};
private AdapterView.OnItemClickListener onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position,
long id) {
current=model.get(position);
name.setText(current.getName());
address.setText(current.getAddress());
notes.setText(current.getNotes());
if (current.getType().equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (current.getType().equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
getTabHost().setCurrentTab(1);
}
};
private Runnable longTask=new Runnable() {
public void run() {
for (int i=progress;
i<10000 && isActive.get();
i+=200) {
doSomeLongWork(200);
}
if (isActive.get()) {
runOnUiThread(new Runnable() {
public void run() {
setProgressBarVisibility(false);
progress=0;
}
});
}
}
};
84
Life and Times
class RestaurantAdapter extends ArrayAdapter<Restaurant> {
RestaurantAdapter() {
super(LunchList.this, R.layout.row, model);
}
public View getView(int position, View convertView, ViewGroup
parent) { View row=convertView;
RestaurarHolder holder=null;
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(R.layout.row, parent, false);
holder=new RestaurantHolder(row);
row.setTag(holder);
}
else {
holder=(RestaurantHolder)row.getTag();
}
holder.populateFrom(model.get(position));
return(row);
}
}
static class RestaurantHolder {
private TextView name=null;
private TextView address=null;
private ImageView icon=null;
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Restaurant r) {
name.setText(r.getName());
address.setText(r.getAddress());
if (r.getType().equals("sit_down")) {
icon.setImageResource(R.drawable.ball_red);
}
else if (r.getType().equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon.setImageResource(R.drawable.ball_green);
}
}
85
Life and Times
}
}
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Have the progress position be persisted via onSaveInstanceState(). When
the activity is started in onCreate(), see if the background work was in
progress when the activity was shut down (i.e., progress further than 0),
and restart the background thread immediately if it was. To test this, you
can press <ctrl>-<Fi2> to simulate opening the keyboard and rotating the
screen - by default, this causes your activity to be destroyed and recreated,
with onSaveInstanceState() called along the way.
•
Try moving the pause/resume logic to onStop() and onStart().
Further Reading
You can find material on the topics shown in this tutorial in the "Handling Activity
Lifecycle Events" chapter of The Busy Coder's Guide to Android Development.
You are also strongly encouraged to read the class overview for Activity in the
JavaDocs.
86
TUTORIAL 10
A Few Good Resources
We have already used many types of resources in the preceding tutorials. After
reviewing what we have used so far, we set up an alternate layout for our LunchList
activity to be used when the activity is in landscape orientation instead of portrait.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 09-Lifecycle edition of
LunchList to use as a starting point.
Step #1: Review our Current Resources
Now that we have completed ten tutorials, this is a good time to recap what
resources we have been using along the way. Right now, LunchList has:
•
Seven icons in LunchList/res/drawable/, all PNGs
•
Two XML files in LunchList/res/layout/, representing the main LunchList
UI and the definition of each row
•
One XML file in LunchList/res/menu/, containing our options menu
definition
•
The system-created strings.xml file in LunchList/res/values/
87
A Few Good Resources
Step #2: Create a Landscape Layout
In theemulator, with LunchList running and showing thedetail form, press <ctrl><Fi2>. This simulates opening and closing the keyboard, causing the screen to
rotate to landscape and portrait, respectively. Our current layout is not very good
in landscape orientation:
So, let us come up with an alternative layout that will work better.
Figure 20. The LunchList in landscape orientation
First, create a LunchList/res/layout-land/ directory in your project. This will hold
layout files thatwe wish to use when the device (or emulator) is in the landscape
orientation.
Then, copy LunchList/res/layout/main.xml into LunchList/res/layout-land/, so we
can start with the same layout we were using for portrait mode.
Then, change the layout to look like this:
<?xml version="1.0" encoding="utf-8"?>
<TabHost xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@android:id/tabhost"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<LinearLayoutandroid:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TabWidget android:id="@android:id/tabs"
android:layout_width="fill_parent"
88
A Few Good Resources
android:layout_height="wrap_content"
/>
<FrameLayout android:id="@android:id/tabcontent"
android:layout_width="fill_parent"
android:layout_height="fill_parent" >
<ListView android:id="@+id/restaurants"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
/>
<TableLayout android:id="@+id/details"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="1,3"
android:paddingTop="4dip" >
<TableRow>
<TextView
android:text="Name:"
android:paddingRight="2dip"
/>
<EditText
android:id="@+id/name"
android:maxWidth="140sp"
/>
<TextView
android:text="Address:"
android:paddingLeft="2dip"
android:paddingRight="2dip"
/>
<EditText
android:id="@+id/addr"
android:maxWidth="140sp"
/>
</TableRow>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android :id="@+id/types">
<RadioButton android:id="@+id/take_out"
android:text="Take-Out"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
<TextView
android:text="Notes:"
android:paddingLeft="2dip"
/>
<LinearLayout
android:layout_width="fill_parent"
89
A Few Good Resources
android:layout_height="fill_parent"
android:orientation="vertical"
>
<EditText android:id="@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="3"
android:scrollHorizontally="false"
android:maxLines="3"
android:maxWidth="140sp"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
/>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</LinearLayout>
</TableRow>
</TableLayout>
</FrameLayout>
</LinearLayout>
</TabHost>
In this revised layout, we:
•
Switched to four columns in our table, with columns #1 and #3 as
stretchable
•
Put the name and address labels and fields on the same row
•
Put the type, notes, and Save button on the same row, with the notes and
Save button stacked viaa LinearLayout
•
Made the notes three lines instead of two, since we have the room
•
Fixed the maximum width of the EditText widgets to 140 scaled pixels
(sp), so they do not automatically grow outlandishly large if we type a lot
•
Added a bit of padding in places to make the placement of the labels and
fields look a bit better
If you rebuild and reinstall the application, then run it in landscape mode, you will
see a form that looks like this:
90
A Few Good Resources
Figure 21. The LunchList in landscape orientation, revised
Note that we did not create a LunchList/res/layout-land/ edition of our row layout
(row.xml). Android, upon not finding one in LunchList/res/layout-land/, will fall
back to the one in LunchList/res/layout/. Since we do not really need our row to
change, we can leave it as-is.
Note that when you change the screen orientation, your existing restaurants will
vanish. That is because we are not persisting them anywhere, and rotating the
screen by default destroys and recreates the activity. These issues will be addressed
in later tutorials.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Find some other icons to use and create a LunchList/res/drawable-land
directory with the replacement icons, using the same names as found in
LunchList/res/drawable. See if exposing the keyboard swaps the icons as
well as the layouts.
•
Change the text of the labels in our main layout file to be string resources.
You will need to add those values to LunchList/res/values/strings.xml and
reference them in LunchList/res/layout/main.xml.
•
Use onSaveinstanceState() to save the current contents of the detail form,
and restore those contents in onCreate() if an instance state is available
(e.g., after the screen was rotated). Note how this does not
91
A Few Good Resources
cover the list - you will still lose all existing restaurants on a rotation event.
However, in a later tutorial, we will move that data to the database, which
will solve that problem.
Further Reading
You can learn more about resource sets, particularly with respect to UI impacts, in
the "Working with Resources" chapter of The Busy Coder's Guide to Android
Development.
You will also find 'Table 2" in the Alternate Resources section of the Android
developer guide to be of great use for determining the priority of different resource
set suffixes.
92
TUTORIAL 11
The Restaurant Store
In this tutorial, we will create a database and table for holding our restaurant data
and switch from our ArrayAdapter to a CursorAdapter, to make use of that database.
This will allow our restaurants to persist from run to run of LunchList.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 10-Resources edition of
LunchList to use as a starting point.
Step #1: Create a Stub SQLiteOpenHelper
First, we need to be able to define what our database name is, what the schema is
for the table for our restaurants, etc. That is best wrapped up in a SQLiteOpenHelper
implementation.
So, create LunchList/src/apt/tutorial/RestaurantHelper.java, and enter in the
following code:
package apt.tutorial;
import android.content.Context;
import android.database.SQLException;
93
The Restaurant Store
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
class RestaurantHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME="lunchlist.db";
private static final int SCHEMA_VERSION=1;
public RestaurantHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { }
}
This says that our database name is lunchlist.db, we are using the first version of
the schema...and not much else. However, the project should still compile cleanly
after adding this class.
Step #2: Manage our Schema
Next, we need to flesh out the onCreate() and onUpgrade() methods in
RestaurantHelper, to actually create the schema we want.
To do this, add an import for android.database.Cursor and use the following
implementation of onCreate ():
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE restaurants (_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,
address TEXT, type TEXT, notes TEXT);"); }
Here, we are simply executing a SQL statement to create a restaurant table with a
particular schema.
For onUpgrade(), there is nothing we really need to do now, since this method will
not be executed untilwe have at least two schema versions. So
94
The Restaurant Store
far, we barely haveour first schemaversion. So, just put acomment to that effect in
onUpgrade() , perhaps something like this:
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// no-op, since will not be called until 2nd schema
// version exists
}
In a production system, of course, we would want to make a temporary table, copy
our current data to it, fix up the real table's schema, then migrate the data back.
Step #3: Remove Extraneous Code from LunchList
With our menu and thread samples behind us, we can get rid of our options menu
and simplify the code. Get rid of the following items from your implementation of
LunchList:
•
The isActive and progress data members
•
The call to requestWindowFeature() in onCreate()
•
The
•
The startWork() and doSomeLongWork() methods, along with the longTask
implementations
of
onPause(), onResume(),
onCreateOptionsMenu(), and onOptionsItemSelected()
Runnable
Step #4: Get Access to the Helper
We will be using RestaurantHelper as our bridge to the database. Hence, LunchList
will need a RestaurantHelper, to retrieve existing restaurants and add new ones.
In order to really use the database, though, we need to open and close access to it
from LunchList.
First, create a RestaurantHelper data member named helper.
95
The Restaurant Store
Then, in onCreate() in LunchList, after the call to setContentView(), initialize
RestaurantHelper like this:
helper=new RestaurantHelper(this);
Finally, implement onDestroy() on LunchList as follows:
@Override
public void onDestroy() {
super.onDestroy();
helper.close();
}
All we do in onDestroy(), besides chain to the superclass, is close the helper we
opened in onCreate() . This will close the underlying SQLite database as well.
Step #5: Save a Restaurant to the Database
We are going to be replacing our restaurant object model (and its associated
ArrayList) with the database and a Cursor representing the roster of restaurants.
This will involve adding some more logic to RestaurantHelper to aid in this process,
while also starting to use it from LunchList.
First,
add
an
import
statement
for
android.content.ContentValues
RestaurantHelper.
Then, implement insert() on RestaurantHelper as follows:
public void insert(String name, String address,
String type, String notes) {
ContentValues cv=new ContentValues();
cv.put("name", name);
cv.put("address",
address); cv.put("type",
type); cv.put("notes",
notes);
getWritableDatabase().insert("restaurants", "name", cv);
}
96
to
The Restaurant Store
With this code, we pour the individual pieces of a restaurant (e.g., its name) into a
ContentValues and tell the SQLiteDatabase to insert it into the database. We call
getWritableDatabase() to get at the SQLiteDatabase. Our helper will automatically
open the database in write mode if it has not already been opened by the helper
before.
Finally, we need to actually call insert() at the appropriate time. Right now, our
Save button adds a restaurant to our RestaurantAdapter - now, we need it to persist
the restaurant to the database. So, modify the onSave object in LunchList to look
like this:
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break;
case R.id.take_out:
type="take_out";
break;
case R.id.delivery:
type="delivery";
break;
}
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString());
}
};
We simply get the four pieces of data from their respective widgets and call
insert() .
Step #6: Get the List of Restaurants from the
Database
This puts restaurants into the database. Presumably, it would be useful to get them
back out sometime. Hence, we need some logic that can query the database and
return a Cursor with columnar data fromour restaurant table. A Cursor in Android
is much like a cursor in other database access libraries
97
The Restaurant Store
- it is an encapsulation of the result set of the query, plus the query that was used
to create it.
o do this, add the following method to RestaurantHelper:
public Cursor getAll() {
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes FROM restaurants ORDER BY
name",
null));
}
Here, we get access to the underlying SQLiteDatabase (opening it in read mode if it
is not already open) and call rawQuery(), passing in a suitable querystring to
retrieve all restaurants, sorted by name.
We will also need to have some way to get the individual pieces of data out of the
Cursor (e.g., name). To that end, add a few getter-style methods to
RestaurantHelper that will retrieve the proper columns from a Cursor positioned on
the desired row:
public String getName(Cursor c) {
return(c.getString(1));
}
public String getAddress(Cursor c) {
return(c.getString(2));
}
public String getType(Cursor c) {
return(c.getString(3));
}
public String getNotes(Cursor c) {
return(c.getString(4));
}
Step #7: Change our Adapter and Wrapper
Of course, our existing RestaurantAdapter extends ArrayAdapter and cannot use a
Cursor very effectively. So, we need to change our RestaurantAdapter into
something that can use a Cursor...such as a CursorAdapter. Just as an
98
The Restaurant Store
ArrayAdapter
CursorAdapter
creates a View for every needed item in an array or List,
creates a View for every needed row in a Cursor.
A CursorAdapter does not use getView(), but rather bindView() and newView(). The
newView() method handles thecasewherewe need to inflate a new row; bindView() is
when we are recycling an existing row. So, our current getView() logic needs to be
split between bindView() and newView() .
Replace our existing RestaurantAdapter implementation in LunchList with the
following:
class RestaurantAdapter extends CursorAdapter {
RestaurantAdapter(Cursor c) {
super(LunchList.this, c);
}
@Override
public void bindView(View row, Context ctxt,
Cursor c) {
RestaurantHolder
holder=(RestaurantHolder)row.getTag();
holder.populateFrom(c, helper);
}
@Override
public View newView(Context ctxt, Cursor c, ViewGroup parent)
{ LayoutInflater inflater=getLayoutInflater();
View row=inflater.inflate(R.layout.row, parent, false);
RestaurantHolder holder=new RestaurantHolder(row);
row.setTag(holder);
return(row);
}
}
Then, you need to make use of this refined adapter, by changing the model in
LunchList from an ArrayList to a Cursor. After you have changed that data
member, replace the current onCreate() code that populates our RestaurantAdapter
with the following:
model=helper.getAll();
startManagingCursor(model);
adapter=new RestaurantAdapter(model);
list.setAdapter(adapter);
99
The Restaurant Store
After getting the Cursor from getAll(), we call startManagingCursor(), so Android
will deal with refreshing its contents if the activity is paused and resumed. Then,
we hand the Cursor off to the RestaurantAdapter.
Also,
you
will
need
to
import
android.widget.CursorAdapter in LunchList.
android.content.Context
and
Then, we need to update RestaurantHolder to work with Cursor objects rather than
a restaurant directly. Replace the existing implementation with the following:
static class RestaurantHolder {
private TextView name=null;
private TextView address=null;
private ImageView icon=null;
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Cursor c, RestaurantHelper helper) {
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
if (helper.getType(c).equals("sit_down")) {
icon.setImageResource(R.drawable.ball_red);
}
else if (helper.getType(c).equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon.setImageResource(R.drawable.ball_green);
}
}
}
Step #8: Clean Up Lingering ArrayList References
Since we changed our model in LunchList from an ArrayList to a Cursor, anything
that still assumes an ArrayList will not work.
100
The Restaurant Store
Notably, the onListClick listener object tries to obtain a restaurant from the
ArrayList. Now, we need to move the Cursor to the appropriate position and get a
restaurant from that. So, modify onListClick to use the Cursor and the property
getter methods on RestaurantHelper instead:
private AdapterView.OnltemClickListener onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position, long id) {
model.moveToPosition(position);
name.setText(helper.getName(model));
address.setText(helper.getAddress(model));
notes.setText(helper.getNotes(model));
if (helper.getType(model).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(model).equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
getTabHost().setCurrentTab(1);
}
At this point, you can recompile and reinstall your application. If you try using it, it
will launch and you can save restaurants to the database. However, you will find
that the list of restaurants will not update unless you exit and restart the LunchList
activity.
Step #9: Refresh Our List
The reason the list does not update is because neither the Cursor nor the
CursorAdapter realize that the database contents have changed when we save our
restaurant. To resolve this, add model.requery(); immediately after the call to
insert() in the onSave object in LunchList. This causes the Cursor to reload its
contents from the database, which in turn will cause the CursorAdapter to redisplay
the list.
101
The Restaurant Store
Rebuild and reinstall the application and try it out. You should have all the
functionality you had before, with the added benefit of restaurants living from run
to run of LunchList.
Here is an implementation of LunchList that incorporates all of the changes shown
in this tutorial:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
android.app.TabActivity;
android.content.Context;
android.database.Cursor;
android.os.Bundle;
android.view.View;
android.view.ViewGroup;
android.view.LayoutInflater;
android.widget.AdapterView;
android.widget.CursorAdapter;
android.widget.Button;
android.widget.EditText;
android.widget.ImageView;
android.widget.ListView;
android.widget.RadioGroup;
android.widget.TabHost;
android.widget.TextView;
public class LunchList extends TabActivity {
Cursor model=null;
RestaurantAdapter adapter=null;
EditText name=null;
EditText address=null;
EditText notes=null;
RadioGroup types=null;
RestaurantHelper helper=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
helper=new RestaurantHelper(this);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
102
The Restaurant Store
ListView list=(ListView)findViewById(R.id.restaurants);
model=helper.getAll();
startManagingCursor(model);
adapter=new RestaurantAdapter(model);
list.setAdapter(adapter);
TabHost.TabSpec spec=getTabHost().newTabSpec("tagl");
spec.setContent(R.id.restaurants);
M
spec.setIndicator( List", getResources()
.getDrawable(R.drawable.list));
getTabHost().addTab(spec);
spec=getTabHost().newTabSpec("tag2");
spec.setContent(R.id.details);
spec.setIndicator(MDetails", getResources()
.getDrawable(R.drawable.restaurant));
getTabHost().addTab(spec);
getTabHost().setCurrentTab(0);
list.setOnItemClickListener(onListClick);
}
@Override
public void onDestroy() {
super.onDestroy();
helper.close();
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break;
case
R.id.take_out:
type="take_out";
break;
case
R.id.delivery:
type="delivery";
break;
}
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString());
model.requery();
}
};
103
The Restaurant Store
private AdapterView.OnItemClickListener onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position, long id) {
model.moveToPosition(position);
name.setText(helper.getName(model));
address.setText(helper.getAddress(model));
notes.setText(helper.getNotes(model));
if (helper.getType(model).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(model).equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
getTabHost().setCurrentTab(1);
}
};
class RestaurantAdapter extends CursorAdapter {
RestaurantAdapter(Cursor c) { super(LunchList.this,
c);
}
@Override
public void bindView(View row, Context ctxt,
Cursor c) {
RestaurantHolder holder=(RestaurantHolder)row.getTag();
holder.populateFrom(c, helper);
}
@Override
public View newView(Context ctxt, Cursor c, ViewGroup parent) {
LayoutInflater inflater=getLayoutInflater();
View row=inflater.inflate(R.layout.row, parent, false);
RestaurantHolder holder=new RestaurantHolder(row);
row.setTag(holder);
return(row);
}
}
static class RestaurantHolder {
private TextView name=null; private
TextView address=null; private
ImageView icon=null;
104
The Restaurant Store
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Cursor c, RestaurantHelper helper) {
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
if (helper.getType(c).equals("sit_down")) {
icon.setImageResource(R.drawable.ball_red);
}
else if (helper.getType(c).equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon.setImageResource(R.drawable.ball_green);
}
}
}
}
Similarly, here is a full implementation of RestaurantHelper that contains the
modifications from this tutorial:
package apt.tutorial;
import
import
import
import
import
import
import
android.content.Context;
android.content.ContentValues;
android.database.Cursor;
android.database.SQLException;
android.database.sqlite.SQLiteOpenHelper;
android.database.sqlite.SQLiteDatabase;
android.database.sqlite.SQLiteQueryBuilder;
class RestaurantHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME="lunchlist.db";
private static final int SCHEMA_VERSION=1;
public RestaurantHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE restaurants (_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,
address TEXT, type TEXT, notes TEXT);"); }
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// no-op, since will not be called until 2nd schema
105
The Restaurant Store
// version exists
}
public Cursor getAll() {
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes FROM restaurants ORDER BY
name",null));
}
public void insert(String name, String address,
String type, String notes) {
ContentValues cv=new ContentValues();
cv.put("name", name);
cv.put("address", address);
cv.put("type", type);
cv.put("notes", notes);
getWritableDatabase().insert("restaurants", "name", cv);
}
public String getName(Cursor c) {
return(c.getString(1));
}
public String getAddress(Cursor c) {
return(c.getString(2));
}
public String getType(Cursor c) {
return(c.getString(3));
}
public String getNotes(Cursor c) {
return(c.getString(4));
}
}
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
• Download the database off the emulator (or device) and examine it using a
SQLite client program. You can use adb pull to download
/data/data/apt.tutorial/databases/lunchlist.db, or use Eclipse or DDMS
to browse the emulator graphically to retrieve the same file.
106
The Restaurant Store
Use adb shell and the sqlite3 program built into the emulator to examine
the database in the emulator itself, without downloading
it.
Further Reading
You can learn more about how Android and SQLite work together in the
"Managing and Accessing Local Databases" chapter of The Busy Coder's Guide to
Android Development.
However, if you are looking for more general documentation on SQLite itself, such
as it's particular flavor of SQL, you will want to use the SQLite site, or perhaps The
Definitive Guide to SQLite.
107
108
TUTORIAL 12
Getting More Active
In this tutorial, we will add support for both creating new restaurants and editing
ones that were previously entered. Along theway, we will get rid of our tabs,
splitting the application into two activities: one for the list, and one for the detail
form.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 11-Database edition of
LunchList to use as a starting point.
Also, for this specific tutorial, since there is a lot of cutting and pasting, you may
wish to save off a copy of your current work before starting in on the
modifications, so you can clip code from the original and paste it where it is
needed.
Step #1: Create a Stub Activity
The first thing we need to do is create an activity to serve as our detail form. In a
flash
of
inspiration,
let's
call
it
DetailForm.
So,
create
a
LunchList/src/apt/tutorial/DetailForm.java file with the following content:
109
Getting More Active
package apt.tutorial;
import android.app.Activity;
import android.os.Bundle;
public class DetailForm extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//
setContentView(R.layout.main);
}
}
This is just a stub activity, except it has the setContentView() line commented out.
That is because we do not want to use main.xml, as that is the layout for LunchList.
Since wedo not haveanother layout ready yet, we can just comment out the line.
As we will see, this is perfectly legal, but it means the activity will have no UI.
Step #2: Launch the Stub Activity on List Click
Now, we need to arrange to display this activity when the user clicks on a LunchList
list item, instead of flipping to the original detail form tab in LunchList.
First, we need to add DetailForm to the AndroidManifest.xml file, so it is recognized
by the system as being an available activity. Change the manifest to look like the
following:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial"
android:versionCode="1"
android:versionName="1.0">
<supports-screens
android:xlargeScreens="true"
android:largeScreens="true"
android:normalScreens="true"
android:smallScreens="false"
/>
application android:label="@string/app_name">
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
110
Getting More Active
category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".DetailForm">
</activity>
</application>
</manifest>
<
Notice the second <activity> element, referencing the DetailForm class. Also note
that it does not need an <intent-filter>, since we will be launching it ourselves
rather than expecting the system to launch it for us.
Then, we need to start this activity when the list item is clicked. That is handled by
our onListClick listener object. So, replace our current implementation with the
following:
private AdapterView.OnItemClickListener onListClick=new
AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent,
View view, int position,
long id) {
Intent
i=new
Intent(LunchList.this,
DetailForm.class);
startActivity(i);
}
Here we create an Intent that points to our DetailForm and call startActivity() on
that Intent. You will need to add an import for android.content.Intent to
LunchList.
At this point, youshould be able to recompile and reinstall the application. If you
run it and click on an item in the list, it will open up the empty DetailForm. From
there, you can click the BACK button to return to the main LunchList activity.
Step #3: Move the Detail Form UI
Now, the shredding begins - we need to start moving our detail form smarts out of
LunchList and its layout to DetailForm.
111
Getting More Active
First, create a LunchList/res/layout/detail_form.xml, using the detail form from
LunchList/res/layout/main.xml as a basis:
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="1" >
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name" />
</TableRow> <TableRow>
<TextView android:text="Address:" />
<EditText android:id="@+id/addr" />
</TableRow
>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android:id="@+id/types">
<RadioButton android:id="@+id/take_out"
android:text="Take-Out"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
</TableRow
>
<TableRow>
<TextView android:text="Notes:" />
<EditText android:id="@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="2"
android:scrollHorizontally="false"
android:maxLines="2"
android:maxWidth="200sp"
/>
</TableRow>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</TableLayout>
This is just the detail form turned into its own standalone layout file.
112
Getting More Active
Next, un-comment the setContentView() call in onCreate() in DetailForm and have
it load this layout:
setContentView(R.layout.detail_form);
Then, we need to add all our logic for accessing the various form widgets, plus an
onSave listener for our Save button, plus all necessary imports.
Set the import list for DetailForm to be:
import
import
import
import
import
import
import
import
android.app.Activity;
android.database.Cursor;
android.os.Bundle;
android.view.View;
android.widget.Button;
android.widget.EditText;
android.widget.RadioGroup;
android.widget.TextView;
Then, add the following data members to the DetailForm class:
EditText name=null;
EditText address=null;
EditText notes=null;
RadioGroup types=null;
RestaurantHelper helper=null;
Then, copy the widget finders and stuff from onCreate() in LunchList into the same
spot in DetailForm:
helper=new RestaurantHelper(this);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
Finally, add the onSave listener object with a subset of the implementation from
LunchList:
113
Getting More Active
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break; case
R.id.take_out:
type="take_out";
break; case
R.id.delivery:
type="delivery";
break;
}
}
};
114
Getting More Active
Step #4: Clean Up the Original UI
Now we need to clean up LunchList and its layout to reflect the fact that we moved
much of the logic over to DetailForm.
First, get rid of the tabs and the detail form from LunchList/res/layout/main.xml,
and alter the ListView's android:id to something suitable for ListActivity, leaving
us with:
<?xml version="1.0" encoding="utf-8"?>
<ListView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@android:id/list"
android:layout_width="fill_parent"
android:layout_height=Mfill_parent"
/>
Next, delete LunchList/res/layout_land/main.xml, as we will revisit landscape
layouts in a later tutorial.
At present, LunchList extends TabActivity, which is no longer what we need.
Change it to extend ListActivity instead, adding an import for
android.app.ListActivity.
Finally, get rid of the code from onCreate() that sets up the tabs and the Save
button, since they are no longer needed. Also, you no longer need to find the
ListView widget, since you can call setListAdapter() on the ListActivity to
associate your RestaurantAdapter with the ListActivity's ListView. You also no
longer need to access the form widgets, since they are no longer in this activity.
The resulting onCreate() implementation should look like:
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.main);
helper=new RestaurantHelper(this);
model=helper.getAll();
startManagingCursor(model);
adapter=new RestaurantAdapter(model);
setListAdapter(adapter);
}
115
Getting More Active
Step #5: Pass the Restaurant _ID
Now, let's step back a bit and think about what we are trying to achieve.
We want to be able to use DetailForm for both adding new restaurants and editing
an existing restaurant. DetailForm needs to be able to tell those two scenarios
apart. Also, DetailForm needs to know which item is to be edited.
To achieve this, we will pass an "extra" in our Intent that launches DetailForm,
containing the ID (_id column) of the restaurant to edit. We will use this if the
DetailForm was launched by clicking on an existing restaurant. If DetailForm
receives an Intent lacking our "extra", it will know to add a new restaurant.
First, we need to define a name for this "extra", so add the following data member
to LunchList:
public final static String ID_EXTRA="apt.tutorial._IDM;
We use the apt.tutorial namespace to ensure our "extra" name will not collide
with any names perhaps used by the Android system.
Next, convert the onListClick object to an onListItemClick() method (available to
us on ListActivity) and have it add this "extra" to the Intent it uses to start the
DetailForm:
@Override
public void onListItemClick(ListView list, View view,
int position, long id) {
Intent i=new Intent(LunchList.this, DetailForm.class);
i.putExtra(ID_EXTRA, String.valueOf(id));
startActivity(i);
}
The _id of the restaurant happens to be provided to us as the fourth parameter to
onListItemClick(). We turn it into a String because DetailForm will want it in
String format, as we will see shortly.
116
Getting More Active
Next, add the following data member to DetailForm:
String restaurantId=null;
This will be null if we areaddinga new restaurant or thestring form of the ID if we
are editing an existing restaurant.
Finally, add the following line to the end of onCreate() in DetailForm:
restaurantId=getIntent().getStringExtra(LunchList.ID_EXTRA);
This will pull out our "extra", or leave restaurantId as null if there is no such
"extra".
Step #6: Load the Restaurant Into the Form
In the case where we are editing an existing restaurant, we need to load that
restaurant from the database, then load it into the DetailForm.
Since we created a RestaurantHelper in onCreate(), we need to close it again, so
add an onDestroy() implementation to DetailForm as follows:
@Override
public void onDestroy() {
super.onDestroy();
helper.close();
}
Now that we have a handle to the database, we need to load a restaurant given its
ID. So, add the following method to RestaurantHelper:
public Cursor getById(String id) {
String[] args={id};
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes FROM restaurants
WHERE _ID=?",
args));
}
117
Getting More Active
Then, add the following lines to the bottom of onCreate() in DetailForm, to load in
the specified restaurant into the form if its ID was specified in the Intent:
if (restaurantId!=null) {
load();
}
The code snippet above references a load() method, which we need to add to
DetailForm, based off of code originally in LunchList:
private void load() {
Cursor c=helper.getById(restaurantId);
c.moveToFirst();
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
notes.setText(helper.getNotes(c));
if (helper.getType(c).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(c).equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
c.close();
}
Step #7: Add an "Add" Menu Option
We have most of the logic in place to edit existing restaurants. However, we still
need to add a menu item for adding a new restaurant.
To do this, change LunchList/res/menu/option.xml to replace the existing options
with one for add:
<?xml version="1.0M encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/add"
android:title="Add"
android:icon="@drawable/ic_menu_add"
118
Getting More Active
/>
</menu>
Note that the add menu item references an icon supplied by Android. You can find
a copy of this icon in your Android SDK. Go to the directory where you installed
the SDK, and go into the platforms/ directory inside of it. Then, go into the
directory for some version of Android (e.g., android-8/), and into
data/res/drawable-mdpi/.You will find ic_menu_add.png in there.
Now that we have the menu option, we need to adjust our menu handling to
match. Restore our older implementation of onCreateOptionMenu() to LunchList:
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.option, menu);
return(super.onCreateOptionsMenu(menu));
}
Then, add an onOptionsItemSelected() implementation in LunchList with the
following:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.add) {
startActivity(new Intent(LunchList.this, DetailForm.class));
return(true);
}
return(super.onOptionsItemSelected(item));
}
Here, we launch the DetailForm activity without our "extra", signalling to
DetailForm that it is to add a new restaurant. You will need imports again for
android.view.Menu, android.view.MenuInflater, and android.view.MenuItem.
Step #8: Detail Form Supports Add and Edit
Last, but certainly not least, we need to have DetailForm properly do useful work
when the Save button is clicked. Specifically, we need to either insert
119
Getting More Active
or update the database. It would also be nice if we dismissed the DetailForm at that
point and returned to the main LunchList activity.
To accomplish this, we first need to add an update() method to RestaurantHelper
that can perform a database update:
public void update(String id, String name, String address, String
type, String notes) {
ContentValues cv=new ContentValues(); String[] args={id};
cv.put("name", name);
cv.put("address",
address); cv.put("type",
type); cv.put("notes",
notes);
getWnitableDatabase().update(Mrestaurants", cv, "_ID=?"
args);
}
Then, we need to adjust our onSave listener object in DetailForm to call the right
method (save() or update()) and finish() our activity:
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) { String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break; case
R.id.take_out:
type="take_out";
break; case
R.id.delivery:
type="delivery";
break;
}
if (restaurantId==null) {
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString());
}
else {
helper.update(restaurantId, name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString());
}
120
Getting More Active
finish();
}
};
At this point, youshould be able to recompile and reinstall the application. When
you first bring up the application, it will no longer show the tabs:
Figure 22. The new-and-improved LunchList
However, it will have an "add" menu option:
121
Getting More Active
Figure 23. The LunchList options menu, with Add
If you choose the "add" menu option, it will bring up a blank DetailForm:
122
Getting More Active
Figure 24. The DetailForm activity
If you fill out the form and click Save, it will return you to the LunchList and
immediately shows the new restaurant (courtesy of our using a managed Cursor in
LunchList):
123
Getting More Active
Figure 25. The LunchList with an added Restaurant
If you click an existing restaurant, it will bring up the DetailForm for that object:
124
Getting More Active
Figure 26. The DetailForm on an existing Restaurant
Making changes and clicking Save will update the database and list:
125
Getting More Active
Figure 27. The LunchList with an edited Restaurant
Here is one implementation of LunchList that incorporates all of this tutorial's
changes:
package apt.tutorial;
import android.app.ListActivity;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.LayoutInflater;
import android.widget.AdapterView;
import android.widget.CursorAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
public class LunchList extends ListActivity {
public final static String ID_EXTRA="apt.tutorial._ID";
Cursor model=null;
126
Getting More Active
RestaurantAdapter adapter=null;
RestaurantHelper helper=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
helper=new RestaurantHelper(this);
model=helper.getAll();
startManagingCursor(model);
adapter=new RestaurantAdapter(model);
setListAdapter(adapter);
}
@Override
public void onDestroy() {
super.onDestroy();
helper.close();
}
@Override
public void onListItemClick(ListView list, View view,
int position, long id) {
Intent i=new Intent(LunchList.this,
DetailForm.class);
i.putExtra(ID_EXTRA, String.valueOf(id));
startActivity(i);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.option, menu);
return(super.onCreateOptionsMenu(menu));
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.add) {
startActivity(new Intent(LunchList.this, DetailForm.class));
return(true);
}
return(super.onOptionsItemSelected(item));
}
class RestaurantAdapter extends CursorAdapter {
RestaurantAdapter(Cursor c) {
super(LunchList.this, c);
}
@Override
127
Getting More Active
public void bindView(View row, Context ctxt,
Cursor c) {
RestaurantHolder
holder=(RestaurantHolder)row.getTag();
holder.populateFrom(c, helper);
}
@Override
public View newView(Context ctxt, Cursor c, ViewGroup parent) {
LayoutInflater inflater=getLayoutInflater();
View row=inflater.inflate(R.layout.row, parent, false);
RestaurantHolder holder=new RestaurantHolder(row);
row.setTag(holder);
return(row);
}
}
static class RestaurantHolder {
private TextView name=null;
private TextView address=null;
private ImageView icon=null;
RestaurantHolder(View row) {
name=(TextView)row.findViewById(R.id.title);
address=(TextView)row.findViewById(R.id.address);
icon=(ImageView)row.findViewById(R.id.icon);
}
void populateFrom(Cursor c, RestaurantHelper helper) {
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
if (helper.getType(c).equals("sit_down")) {
icon.setImageResource(R.drawable.ball_red);
}
else if (helper.getType(c).equals("take_out")) {
icon.setImageResource(R.drawable.ball_yellow);
}
else {
icon.setImageResource(R.drawable.ball_green);
}
}
}
}
Here is one implementation of DetailForm that works with the revised LunchList:
package apt.tutorial;
128
Getting More Active
import
import
import
import
import
import
import
import
android.app.Activity;
android.database.Cursor;
android.os.Bundle;
android.view.View;
android.widget.Button;
android.widget.EditText;
android.widget.RadioGroup;
android.widget.TextView;
public class DetailForm extends Activity {
EditText name=null; EditText address=null;
EditText notes=null; RadioGroup types=null;
RestaurantHelper helper=null; String
restaurantId=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.detail_form);
helper=new RestaurantHelper(this);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
restaurantId=getIntent().getStringExtra(LunchList.ID_EXTRA);
if (restaurantId!=null) {
load();
}
}
@Override
public void onDestroy() {
super.onDestroy();
helper.close();
}
private void load() {
Cursor c=helper.getById(restaurantId);
c.moveToFirst();
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
notes.setText(helper.getNotes(c));
129
Getting More Active
if (helper.getType(c).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(c).equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
c.close();
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) { String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break; case
R.id.take_out:
type="take_out";
break; case
R.id.delivery:
type="delivery";
break;
}
if (restaurantId==null) {
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString());
}
else {
helper.update(restaurantId, name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString());
}
finish();
}
};
}
And, here is an implementation of RestaurantHelper with the changes needed by
DetailForm:
package apt.tutorial;
import android.content.Context;
import android.content.ContentValues;
import android.database.Cursor;
130
Getting More Active
import
import
import
import
android.database.SQLException;
android.database.sqlite.SQLiteOpenHelper;
android.database.sqlite.SQLiteDatabase;
android.database.sqlite.SQLiteQueryBuilder;
class RestaurantHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME="lunchlist.db";
private static final int SCHEMA_VERSION=1;
public RestaurantHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE restaurants (_id INTEGER PRIMARY KEY AUTOINCREMENT, name
TEXT, address TEXT, type TEXT, notes TEXT);"); }
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // no-op,
since will not be called until 2nd schema // version exists
}
public Cursor getAll() {
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes FROM restaurants ORDER
BY name",null));
}
public Cursor getById(String id) {
String[] args={id};
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes FROM restaurants
WHERE _ID=?",
args));
}
public void insert(String name, String address, String
type, String notes) {
ContentValues cv=new ContentValues();
cv.put("name", name);
cv.put("address",address);
cv.put("type", type);
cv.put("notes", notes);
getWritableDatabase().insert("restaurants", "name", cv);
}
public void update(String id, String name, String address,
131
Getting More Active
String type, String notes) {
ContentValues cv=new ContentValues(); String[]
args={id};
cv.put("name", name);
cv.put("address", address);
cv.put("type", type);
cv.put("notes", notes);
getWritableDatabase().update("restaurants", cv, "_ID=?",
args);
}
public String getName(Cursor c) {
return(c.getString(1));
}
public String getAddress(Cursor c) {
return(c.getString(2));
}
public String getType(Cursor c) {
return(c.getString(3));
}
public String getNotes(Cursor c) {
return(c.getString(4));
}
}
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Have the database hold a URL for the restaurant's Web site. Update the UI
to collect this address in the detail form. Launch that URL via
startActivity() via an options menu choice from the restaurant list, so
you can view the restaurant's Web site.
•
Add an options menu to delete a restaurant. Raise an AlertDialog to
confirm that the user wants the restaurant deleted. Delete it from the
database and refresh the list if the user confirms the deletion.
132
Getting More Active
Further Reading
You can read up on having multiple activities in your application, or linking to
activities supplied by others, in the "Launching Activities and Sub-Activities"
chapter of The Busy Coder's Guide to Android Development.
133
134
TUTORIAL 13
What's Your Preference?
In this tutorial, we will add a preference setting for the sort order of the restaurant
list. To do this, we will create a PreferenceScreen definition in XML, load that into a
PreferenceActivity, connect that activity to the application, and finally actually
use the preference to control the sort order.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 12-Activities edition of
LunchList to use as a starting point.
Step #1: Define the Preference XML
First, add a LunchList/res/xml/preferences.xml file as follows:
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android">
<ListPreference
android:key="sort_order" android:title="Sort Order"
android:summary="Choose the order the list uses"
android:entries="@array/sort_names"
android:entryValues="@array/sort_clauses"
android:dialogTitle="Choose a sort order" />
</PreferenceScreen>
135
What's Your Preference?
This sets up a single-item PreferenceScreen. Note that it references two string
arrays, one for the display labels of the sort-order selection list, and one for the
values actually stored in the SharedPreferences.
So, to define those string arrays, add a LunchList/res/values/arrays.xml file with
the following content:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string-array name="sort_names">
<item>By Name, Ascending</item>
<item>By Name, Descending</item>
<item>By Type</item>
<item>By Address, Ascending</item>
<item>By Address, Descending</item>
</string-array>
<string-array name="sort_clauses">
<item>name ASC</item>
<item>name DESC</item>
<item>type, name ASC</item>
<item>address ASC</item>
<item>address DESC</item>
</string-array>
</resources>
Note we are saying that the value stored in the SharedPreferences will actually be
an ORDER BY clause for use in our SQL query. This is a convenient trick, though it
does tend to make the system a bit more fragile - if we change our column names,
we might have to change our preferences to match and deal with older invalid
preference values.
Step #2: Create the Preference Activity
Next, we need to create a PreferenceActivity that will actually use these
preferences.To do this, add a PreferenceActivity implementation, stored as
LunchList/src/apt/tutorial/EditPreferences.java:
package apt.tutorial;
import android.app.Activity;
import android.os.Bundle;
import android.preference.PreferenceActivity;
public class EditPreferences extends PreferenceActivity {
136
What's Your Preference?
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
addPreferencesFromResource(R.xml.preferences);
}
}
We also need to update AndroidManifest.xml to reference this activity, so we can
launch it later:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial"
android:versionCode="1"
android:versionName="1.0">
<supports-screens
android:xlargeScreens="true"
android:largeScreens="true"
android:normalScreens="true"
android:smallScreens="false"
/>
application android:label="@string/app_name">
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" /> <category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".DetailForm">
</activity>
<activity android:name=".EditPreferences"> </activity>
</application> </manifest>
Step #3: Connect the Preference Activity to the Option
Now, we can add a menu option to launch the EditPreferences activity.
We need to add another <item> to our LunchList/res/menu/option.xml file:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/add"
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/add"
137
What's Your Preference?
android:title="Add"
android:icon="@drawable/ic_menu_add"
/>
<item android:id="@+id/prefs"
android:title="Settings"
android:icon="@drawable/ic_menu_preferences"
/>
</menu>
We reference an ic_menu_preferences.png file, which you can obtain from the same
directory where you got ic_menu_add. png.
Of course, if we modify the menu XML, we also need to modify the LunchList
implementation of onOptionsItemSelected() to match, so replace the current
implementation with the following:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.add) {
startActivity(new Intent(LunchList.this, DetailForm.class));
return(true);
}
else if (item.getItemId()==R.id.prefs) {
startActivity(new Intent(this, EditPreferences.class));
return(true);
}
return(super.onOptionsItemSelected(item));
}
All we are doing is starting up our EditPreferences activity.
If you recompile and reinstall the application, you will see our new menu option:
138
What's Your Preference?
Figure 28. The LunchList with the new menu option
And if you choose that menu option, you will get the EditPreferences activity:
139
What's Your Preference?
Figure 29. The preferences activity
Clicking the Sort Order item will bring up a selection list of available sort orders:
140
What's Your Preference?
Figure 30. The available sort orders
Of course, none of this is actually having any effect on the sort order itself, which
we will address in the next section.
Step #4: Apply the Sort Order on Startup
Now, given that the user has chosen a sort order, we need to actually use it. First,
we can apply it when the application starts up - the next section will handle
changing the sort order after the user changes the preference value.
First, the getAll() method on RestaurantHelper needs to take a sort order as a
parameter, rather than apply one of its own. So, change that method as follows:
public Cursor getAll(String orderBy) {
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes FROM restaurants ORDER BY
"+orderBy,
null));
}
141
What's Your Preference?
Then, we need to get our hands on our SharedPreferences instance. Add imports to
LunchList
for
android.content.SharedPreferences
and
android.preference.PreferenceManager, along with a SharedPreferences data member
named prefs.
Next, add this line near the top of onCreate() in LunchList, to initialize prefs to be
the SharedPreferences our preference activity uses:
prefs=PreferenceManager.getDefaultSharedPreferences(this);
Finally, change the call to getAll() to use the SharedPreferences:
model=helper.getAll(prefs.getString("sort_order", "name"));
Here, we use name as the default value, so if the user has not specified a sort order
yet, the sort order will be by name.
Now, if you recompile and reinstall the application, then set a sort order
preference, you can see that preference take effect if you exit and reopen the
application.
Step #5: Listen for Preference Changes
That works, but users will get annoyed if they have to exit the application just to
get their preference choice to take effect. To change the sort order on the fly, we
first need to know when they change the sort order.
has the notion of a preference listener object, to be notified on
such changes. To take advantage of this, add the following line at the end of
onCreate() in LunchList:
SharedPreferences
prefs.registerOnSharedPreferenceChangeListener(prefListener);
This snippet refers to a prefListener object, so add the following code to LunchList
to create a stub implementation of that object:
142
What's Your Preference?
private SharedPreferences.OnSharedPreferenceChangeListener prefListener= new
SharedPreferences.OnSharedPreferenceChangeListener() {
public void onSharedPreferenceChanged(SharedPreferences sharedPrefs, String
key) {
if (key.equals("sort_order")) {
}
}
};
All we are doingright now is watching for our specific preference of interest
(sort_order), though we are not actually taking advantage of the changed value.
Step #6: Re-Apply the Sort Order on Changes
Finally, we actually need to change the sortorder. For simple lists like this, the
easiest way to accomplish this is to get a fresh Cursor representing our list (from
getAll() on RestaurantHelper) with the proper sortorder, and use the new Cursor
instead of the old one.
First, pull some of the list-population logic out of onCreate(), by implementing an
initList() method as follows:
private void initList() {
if (model!=null) {
stopManagingCursor(model);
model.close();
}
model=helper.getAll(prefs.getString("sort_order", "name"));
startManagingCursor(model); adapter=new RestaurantAdapter(model);
setListAdapter(adapter);
}
Note that we call stopManagingCursor() so Android will ignore the old Cursor, then
we close it, before we get and apply the new Cursor. Of course, we only do those
things if there is an old Cursor.
The onCreate() method needs to change to take advantage of initList():
143
What's Your Preference?
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.main);
helper=new RestaurantHelper(this);
prefs=PreferenceManager.getDefaultSharedPreferences(this);
initList();
prefs.registerOnSharedPreferenceChangeListener(prefListener);
}
Also, we can call initList() from prefListener:
private SharedPreferences.OnSharedPreferenceChangeListener prefListener= new
SharedPreferences.OnSharedPreferenceChangeListener() { public void
onSharedPreferenceChanged(SharedPreferences sharedPrefs, String key) {
if (key.equals("sort_order")) {
initList();
}
}
};
At this point, if you recompile and reinstall the application, you should see the sort
order change immediately as you change the order via the preferences.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Add a preference for the default type of restaurant (e.g., take-out). Use
that preference in detail forms when creating a new restaurant.
•
Add an options menu to the detail form activity and have it beable to start
the preference activity the way we did from the option menu for the list.
•
Rather than use preferences, store the preference values in a JSON file that
you read in at startup and re-read in onResume() (to find out about
changes). This means you will need to create your own preference UI,
rather than rely upon the one created by the preference XML.
144
What's Your Preference?
Further Reading
Learn more about setting up preference XML files and reading shared preferences
in the "Using Preferences" chapter of The Busy Coder's Guide to Android
Development.
145
146
TUTORIAL 14
Turn, Tu r n, Turn
In this tutorial, we will make our application somewhat more intelligent about
screen rotations, ensuring that partially-entered restaurant information remains
intact even after the screen rotates.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 13-Prefs edition of
LunchList to use as a starting point.
Step #1: Add a Stub onSaveInstanceState()
Since we are not holding onto network connections or other things that cannot be
stored in a Bundle, we can use onSaveInstanceState() to track our state as the
screen is rotated.
To that end, add a stub implementation of onSaveInstanceState() to DetailForm as
follows:
@Override
public void onSaveInstanceState(Bundle state) {
super.onSaveInstanceState(state);
}
147
urn, Turn, Turn
Step #2: Pour the Form Into the Bundle
Now, fill in the details of onSaveInstanceState(), putting our widget contents into
the supplied Bundle:
@Override
public void onSaveInstanceState(Bundle state) {
super.onSaveInstanceState(state);
state.putString("name", name.getText().toString());
state.putString("address", address.getText().toString());
state.putString("notes", notes.getText().toString());
state.putInt("type", types.getCheckedRadioButtonId());
}
Step #3: Repopulate the Form
Next, we need to make use of that saved state. We could do this in onCreate(), if
the passed-in Bundle is non-null. However, it is usually easier just to override
onRestoreInstanceState(). This is called only when there is state to restore,
supplying the Bundle with your state. So, add an implementation of
onRestoreInstanceState() to DetailForm:
@Override
public void onRestoreInstanceState(Bundle state) {
super.onRestoreInstanceState(state);
name. setText(state.getString("name"));
address.setText(state.getString("address"));
notes.setText(state.getString("notes"));
types.check(state.getInt("type"));
}
At this point, you can recompile and reinstall the application. Use <ctrl>-<F12> to
simulate rotating the screen of your emulator. If you do this after making changes
(but not saving) on the DetailForm, you will see those changes survive the rotation.
Step #4: Fix Up the Landscape Detail Form
As you tested the work from the previous section, you no doubt noticed that the
DetailForm layout is not well-suited for landscape - the notes text
148
Turn, Turn, Turn
area is chopped off and the Save button is missing. To fix this, we need to create a
LunchList/res/layout-land/detail_form.xml file, derived from our original, but set
up to take advantage of the whitespace to the right of the radio buttons:
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="1,3" >
<TableRow>
<TextView android:text="Name/>
<EditText android:id="@+id/name"
android:layout_span="3"
/>
</TableRow
>
<TableRow>
<TextView android:text="Address/>
<EditText android:id="@+id/addr"
android:layout_span="3"
/>
</TableRow
>
<TableRow>
<TextView android:text="Type/> <RadioGroup
android:id="@+id/take_out"
android:text="Take-Out"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
<TextView android:text="Notes/>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<EditText android:id="@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="4"
android:scrollHorizontally="false"
android:maxLines="4"
android:maxWidth="140sp"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
/>
<Button android:id="@+id/save"
149
Turn, Turn, Turn
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</LinearLayout>
</TableRow>
</TableLayout>
Now, if you recompile and reinstall the application, you should see a better
landscape rendition of the detail form:
Figure 31. The new landscape layout
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Try
switching
to
onRetainNonConfigurationInstance()
instead
of
onSaveInstanceState().
•
Try commenting out onSaveInstanceState(). Does the activity still retain
its instance state? Why or why not?
•
Have the application automatically rotate based on physical orientation
instead of keyboard position. Hint: find a place to apply
android:screenOrientation = "sensor".
150
Turn, Turn, Turn
Further Reading
Additional coverage of screen rotations and how to control what happens during
them can be found in the "Handling Rotation" chapter of The Busy Coder's Guide
to Android Development.
151
152
Feeding at Lunch
TUTORIAL 15
Feeding at Luch
Right now, our LunchList application simply displays data that the user entered. It
would be nice to collect more information about a restaurant, culled from other
places online. In this tutorial, we allow users to attach an RSS feed URL to a
restaurant. Then, we allow them to view the latest titles in the feed via a new
ListActivity. To do this, we will need to download the feed from the Internet,
then parse it - to do this, we will take advantage of a third-party JAR file.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 14-Rotation edition of
LunchList to use as a starting point.
Step #1: Add a Feed URL to the Data Model
First, we need to track the feed URL in our data model. This means we need to
adjust our database and our RestaurantHelper (so we can retrieve and set the URL).
First, modify onCreate() of RestaurantHelper to add a new TEXT column named
feed:
153
Feeding at Lunch
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE restaurants (_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,
address TEXT, type TEXT, notes TEXT, feed TEXT);"); }
This also means that we have changed our schema, so we need to change our
SCHEMA_VERSION in RestaurantHelper to match:
private static final int SCHEMA_VERSION=2;
Also, now we need to contend with upgrading our existing database, for those
users who already have LunchList installed and do not wish to lose all their
precious restaurant data. This means we need to replace our original "no-op"
RestaurantHelper onUpgrade() with one that will execute an ALTER TABLE statement
to add this column:
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("ALTER TABLE restaurants ADD COLUMN feed TEXT");
}
Plus, we need to adjust our RestaurantHelper methods that operate on the
database, including getAll(), getById(), insert(), and update():
public Cursor getAll(String orderBy) {
return(getReadableDatabase()
rawQuery("SELECT _id, name, address, type, notes, feed FROM restaurants ORDER BY
"+orderBy, null));
}
public Cursor getById(String id) {
String[] args={id};
return(getReadableDatabase()
rawQuery("SELECT _id, name, address, type, notes, feed FROM restaurants WHERE
_ID=?",
args));
}
public void insert(String name, String address,
String type, String notes, String feed) {
ContentValues cv=new ContentValues();
cv.put("name", name);
154
Feeding at Lunch
cv.put("address",
address); cv.put("type",
type); cv.put("notes",
notes); cv.put("feed",
feed);
getWritableDatabase().insert("restaurants", "name", cv);
}
public void update(String id, String name, String address,
String type, String notes, String feed) {
ContentValues cv=new ContentValues(); String[] args={id};
cv.put("name", name);
cv.put("address",
address); cv.put("type",
type); cv.put("notes",
notes); cv.put("feed",
feed);
getWritableDatabase().update("restaurants", cv, "_ID=?",
args);
}
And, we should add a new getFeed() method on RestaurantHelper to retrieve our
feed URL from a Cursor returned by getAll () or getById ():
public String getFeed(Cursor c) {
return(c.getString(5));
}
The complete revised RestaurantHelper class now looks something like this:
package apt.tutorial;
import android.content.Context;
import android.content.ContentValues;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
class RestaurantHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME="lunchlist.db";
private static final int SCHEMA_VERSION=2;
public RestaurantHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}
@Override
155
Feeding at Lunch
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE restaurants (_id INTEGER PRIMARY KEY AUTOINCREMENT, name
TEXT, address TEXT, type TEXT, notes TEXT, feed TEXT);"); }
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("ALTER TABLE restaurants ADD COLUMN feed TEXT");
}
public Cursor getAll(String orderBy) {
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes, feed FROM restaurants ORDER
BY "+orderBy, null));
}
public Cursor getById(String id) {
String[] args={id};
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes, feed FROM
restaurants WHERE _ID=?",args));
}
public void insert(String name, String address,
String type, String notes, String feed) {
ContentValues cv=new ContentValues();
cv.put("name", name);
cv.put("address",
address); cv.put("type",
type); cv.put("notes",
notes); cv.put("feed",
feed);
getWritableDatabase().insert("restaurants", "name", cv);
}
public void update(String id, String name, String address,
String type, String notes, String feed) {
ContentValues cv=new ContentValues(); String[] args={id};
cv.put("name", name);
cv.put("address",
address); cv.put("type",
type); cv.put("notes",
notes); cv.put("feed",
feed);
getWritableDatabase().update("restaurants", cv, "_ID=?"args);
}
156
Feeding at Lunch
public String getName(Cursor c) {
return(c.getString(1));
}
public String getAddress(Cursor c) {
return(c.getString(2));
}
public String getType(Cursor c) {
return(c.getString(3));
}
public String getNotes(Cursor c) {
return(c.getString(4));
}
public String getFeed(Cursor c) {
return(c.getString(5));
}
}
Step #2: Update the Detail Form
The next problem is that our detail form is getting a wee bit crowded. We do not
really have much room for adding another field, so we will need to use a bit of
creativity to allow our form to still work on HVGA displays, in addition to larger
ones.
Change the res/layout/detail_form.xml resource to look like this:
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="1" >
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name" />
</TableRow>
<TableRow>
<TextView android:text="Address:" />
<EditText android:id="@+id/addr" />
</TableRow>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android:id="@+id/types">
<RadioButton android:id="@+id/take_out"
android:text="Take-Out"
157
Feeding at Lunch
/>
<RadioButton android: id="(@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
</TableRow>
<EditText android:id="@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="2"
android:scrollHorizontally="false"
android:maxLines="2"
android:maxWidth="200sp"
android:hint="Notes"
/>
<EditText android:id="@+id/feed"
android:hint="Feed URL"
/>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</TableLayout>
We have dropped the label for the notes field, replacing it with a hint. The hint will
be displayed if the EditText is empty; otherwise, it will show what the user has
typed in. Our new feed EditText also uses a hint instead of a label, and both are
direct children of the TableLayout, like the Button, so they fill the entire row.
Similarly, change the res/layout-land/detail_form.xml resource to look like
this:
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="2" >
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name"
android:layout_span="2"
/>
</TableRow>
<TableRow>
158
Feeding at Lunch
<TextView android:text="Address:" />
<EditText android:id="@+id/addr"
android:layout_span="2"
/>
</TableRow
>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android:id="@+id/types">
<RadioButton android:id="@+id/take_out"
android:text="Take-Out"
/>
<RadioButton android: id="(@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<EditText android: id="(@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="4"
android:scrollHorizontally="false"
android:maxLines="4"
android:maxWidth="140sp"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:hint="Notes"
/>
<EditText android:id="@+id/feed"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:hint="Feed URL"
/>
<Button android:id="@+id/save"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Save"
/>
</LinearLayout>
</TableRow>
</TableLayout>
Again, we have switched to hints instead of labels, plus added the feed EditText.
159
Feeding at Lunch
This also requires some changes to the DetailForm class. Add a new EditText data
member named feed:
EditText feed=null;
Then, add a statement to the onCreate() method of DetailForm that uses
findViewByid() to retrieve that EditText widget from the inflated layout, after the
similar statements for the other widgets:
feed=(EditText)findViewById(R.id.feed);
The load() method will need to populate the feed widget from the data model, so
add a statement that performs that after all the other similar statements:
feed.setText(helper.getFeed(c));
Finally, the onSave object's onClick() method will need to change its calls to
insert() and update() on the RestaurantHelper to add in the feed URL:
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {
String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break; case
R.id.take_out:
type="take_out";
break; case
R.id.delivery:
type="delivery";
break;
}
if (restaurantId==null) {
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toSt ring());
}
else {
helper.update(restaurantId, name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
160
Feeding at Lunch
feed.getText().toString());
}
finish();
}
};
Step #3: Add a Feed Options Menu Item
Next, we need to give the user the ability to launch another activity to view the
latest items from a restaurant's RSS feed. A likely way to do that would be via an
options menu. Right now, though, the detail form does not have an options menu,
so we will need to add one.
First, create a new file, res/menu/details_option.xml, with the following content:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"> <item
android:id="@+id/feed"
android:title="RSS Feed"
android:icon="@drawable/ic_menu_friendslist"
/>
</men
u>
It has a single menu item, to be used to view the feed. You will need to add a
suitable icon to your project's res/drawable/ directory as well, such as copying the
ic_menu_friendslist.png file from your SDK installation.
Then, add an onCreateOptionsMenu() method to DetailForm, using a Menuinflate4
object to load the menu resource and display it when the user chooses the menu:
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.details_option, menu);
return(super.onCreateOptionsMenu(menu));
}
161
Feeding at Lunch
We will add the corresponding onOptionsItemSelected() method in the next
section. Note that you will need to add imports to android.view.Menu and
android.view.Menulnflater.
Step #4: Add Permissions and Check Connectivity
It would be nice if we would check to see if there is an Internet connection before
going ahead and trying to fetch the feed given its URL. After all, if there is no
connectivity, there is no point in trying and failing with some ugly error.
With that in mind, add an onOptionsItemSelected() method, and an accompanying
isNetworkAvailable() method, to DetailForm that look like
this:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.feed) {
if(isNetworkAvailable()){
Intent i=new Intent(this, FeedActivity.class);
i.putExtra(FeedActivity.FEED_URL,feed.getText().toString());
startActivity(i);
}
else {
Toast
.makeText(this, "Sorry, the Internet is not available",
Toast LENGTH_LONG)
.show();
}
return(true);
}
return(super.onOptionsItemSelected(item));
}
private boolean isNetworkAvailable() {
ConnectivityManager
cm=(ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo info=cm.getActiveNetworkInfo();
return(info!=null);
}
162
Feeding at Lunch
Here,
we
call
getSystemService()
to obtain a ConnectivityManager.
knows the state of data access overall, not via some particular
technology (e.g., WiFi). Specifically, we see if getActiveNetworkInfo() returns a
non-null object - if so, the device thinks it has a network connection. Of course,
there could be problems with that connection (e.g., connected to a WiFi router,
but unable to access certain URLs), but at least we can detect obvious problems.
ConnectivityManager
If there is an Internet connection, onOptionsItemSelected() goes ahead and starts up
a yet-to-be-defined activity named FeedActivity, tucking the feed URL in an Intent
extra. If there is no Internet connection, we display a Toast instead.
You will need to add imports for:
•
android.content.Intent
•
android.net.ConnectivityManager
•
android.net.NetworkInfo
•
android.view.MenuItem
•
android.widget.Toast
The complete modified DetailForm class should look something like this:
package apt.tutorial;
import android.app.Activity;
import android.content.Intent;
import android.database.Cursor;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RadioGroup;
import android.widget.TextView;
import android.widget.Toast;
public class DetailForm extends Activity {
EditText name=null;
163
Feeding at Lunch
EditText address=null;
EditText notes=null;
EditText feed=null;
RadioGroup types=null;
RestaurantHelper helper=null;
String restaurantId=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.detailform);
helper=new RestaurantHelper(this);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
feed=(EditText)findViewById(R.id.feed);
Button save=(Button)findViewById(R.id.save);
save.setOnClickListener(onSave);
restaurantId=getIntent().getStringExtra(LunchList.IDEXTRA);
if (restaurantId!=null) {
load();
}
}
@Override
public void onDestroy() {
super.onDestroy();
helper.close();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.details_option, menu);
return(super.onCreateOptionsMenu(menu));
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.feed) { if (isNetworkAvailable()) {
Intent i=new Intent(this, FeedActivity.class);
i.putExtra(FeedActivity.FEED_URL,feed.getText().toString());
startActivity(i);
}
else {
164
Feeding at Lunch
Toast
.makeText(this, "Sorry, the Internet is not available",
Toast.LENGTH_LONG)
.show();
}
return(true);
}
return(super.onOptionsItemSelected(item));
}
private boolean isNetworkAvailable() {
ConnectivityManager
cm=(ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo info=cm.getActiveNetworkInfo();
return(info!=null);
}
private void load() {
Cursor c=helper.getById(restaurantId);
c.moveToFirst();
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
notes.setText(helper.getNotes(c));
feed.setText(helper.get Feed(c));
if (helper.getType(c).equals("sit_down")) {
types.check(R.id.sitdown);
}
else if (helper.getType(c).equals("take_out")) {
types.check(R.id.takeout);
}
else {
types.check(R.id.delivery);
}
c.close();
}
private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) { String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break;
case R.id.take_out:
type="take_out";
break;
case R.id.delivery:
type="delivery";
165
Feeding at Lunch
break;
}
if (restaurantId==null) {
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toString());
}
else {
helper.update(restaurantId, name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toString());
}
finish();
}
};
}
Also, we need to add our first permissions to our manifest, as we are starting to
access device capabilities that require user agreement. Add the
INTERNET and ACCESS_NETWORK_STATE permissions to your AndroidManifest.xml file, as
children of the root <manifest> element:
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Step #5: Install the RSS Library
To download and parse the feed, we could use HttpUrlConnection or HttpClient to
retrieve the content at the URL, then roll a DOM- or SAX-based parser to get at
the data.
We could.
But we won't. Because we're lazy.
Instead, we will reuse an existing library for this purpose, android-rss, released
under the Apache 2.0 license.
166
Feeding at Lunch
At the time of this writing, the author of that component only publishes source
code, not a JAR, but you can download a JAR from this URL. Copy that JAR into
the libs/ directory of your project.
Eclipse users will also need to add the library to the build path - this is automatic if
you are building via Ant. Eclipse users should right-click over the project name in
the project explorer, then choose Build Path > Configure Build Path from the
context menu. Click on the Libraries tab, then click the "Add JARs" button. Find
the android-rss.jar file in your project's libs/ directory and select it. Then, you
can close up this project properties window.
Step #6: Fetch and Parse the Feed
Now we are in position to start work on the FeedActivity - the class that will
arrange to retrieve and display the RSS feed.
Start a new FeedActivity class, inheriting from ListActivity, in the project
package. Do not worry about any methods on the class right now - we will add
some of those in a bit.
Add FeedActivity to your manifest, by adding another <activity> element. The
resulting AndroidManifest.xml file should looksomething like this:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial" android:versionCode="1"
android:versionName="1.0">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<supports-screens
android:xlargeScreens="true"
android:largeScreens="true"
android:normalScreens="true"
android:smallScreens="false"
/>
application android:label="@string/app_name">
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
167
Feeding at Lunch
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".DetailForm">
</activity>
<activity android:name=".EditPreferences">
</activity>
<activity android:name=".FeedActivity">
</activity>
</application>
</manifest>
Then, add a static inner class named FeedTask to FeedActivity that looks like
this:
private static class FeedTask extends AsyncTask<String, Void, RSSFeed> {
private RSSReader reader=new RSSReader();
private Exception e=null;
private FeedActivity activity=null;
FeedTask(FeedActivity activity) {
attach(activity);
}
void attach(FeedActivity activity) {
this.activity=activity;
}
void detach() {
this.activity=null;
}
@Override
public RSSFeed doInBackground(String... urls) {
RSSFeed result=null;
try {
result=reader.load(urls[0]);
}
catch (Exception e)
{ this.e=e;
}
return(result);
}
@Override
public void onPostExecute(RSSFeed feed) {
if (e==null) {
activity.setFeed(feed);
}
else {
Log.e("LunchList", "Exception parsing feed", e);
168
Feeding at Lunch
activity.goBlooey(e);
}
}
}
is an AsyncTask, designed to wrap a thread and Handler and deal with
background operations on our behalf. The doInBackground() uses an RSSReader
object to load an RSSFeed, given the URL. This one statement takes care of
downloading and parsing it, courtesy of our helper JAR. doInBackground() passes
the RSSFeed object to onPostExecute(), which calls a setFeed() method that we will
eventually implement on FeedActivity. If an exception occurs while retrieving or
parsing the feed (e.g., the URL is not an RSS resource), doInBackground() catches
the Exception and onPostExecute() logs it to LogCat and hands it to FeedActivity.
FeedTask
The FeedTask constructor takes the FeedActivity as a parameter. This is needed
because FeedTask is a static inner class, and therefore does not automatically get
access to the outer class instance. As we will see in the next two sections, we need
to attach and detach the activity from the task as part of handling configuration
changes, such as screen rotations.
Also, go ahead and implement goBlooey() on FeedActivity, raising an AlertDialog
if an Exception is encountered:
private void goBlooey(Throwable t) {
AlertDialog.Builder builder=new AlertDialog.Builder(this);
builder
.setTitle("Exception!")
.setMessage(t.toString())
.setPositiveButton("OK", null)
.show();
}
ou will need the following imports:
•
android.app.AlertDialog
•
android.app.ListActivity
•
android.os.AsyncTask
•
android.util.Log
•
org.mcsoxford.rss.RSSReader
169
Feeding at Lunch
org.mcsoxford.rss.RSSFeed
Step #7: Display the Feed Items
Finally, we need to actually use the ListView in FeedActivity to display the results
of the feed.
Immediately, we run into yet another challenge. RSSFeed is our data model. It has a
getItems() method that returns a List<RSSItem>. We could wrap that List in an
ArrayAdapter. However, to demonstrate another solution, let's create a totally
different adapter, a FeedAdapter, extended from BaseAdapter. BaseAdapter handles
the basic adapter operations - we just need to override a handful of methods.
So, add an inner class named FeedAdapter to FeedActivity, that looks like
this:
private class FeedAdapter extends BaseAdapter {
RSSFeed feed=null;
FeedAdapter(RSSFeed feed)
{ super();
this.feed=feed;
}
@Override
public int getCount() {
return(feed.getItems().size());
}
@Override
public Object getItem(int position) {
return(feed.getItems().get(position));
}
@Override
public long getItemId(int position) {
return(position);
}
@Override
public View getView(int position, View convertView,
ViewGroup parent) {
View row=convertView;
170
Feeding at Lunch
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(android.R.layout.simple_list_item_1,
parent,false);
}
RSSItem item=(RSSItem)getItem(position);
((TextView)row).setText(item.getTitle());
return(row);
}
}
A BaseAdapter subclass, at minimum, needs to implement:
•
getcount (),
•
getItem(),
•
getItemId(),
•
getItem(),
to return how many items are in the adapter
to return a model object (e.g., an RSSItem) given a position
to return a unique long ID for a position - in this case, we just
use the position itself
as we would with an ArrayAdapter, except that we have to
inflate rows ourself, rather than perhaps relying upon the superclass to do
that for us
In the case of getItem() , we simply pour each item's title into an
android.R.layout.simple_list_item_1 row.
The next problem is thinking about handling configuration changes. Any time you
fork a background thread from an Activity - whether directly or via an AsyncTask you really need to think about how you aregoing to deal with a screen rotation or
other configuration change. We want to ensure that when our FeedTask gets to
onPostExecute() that it is updating the FeedActivity instance that is on the screen,
nota FeedActivity instance that happened to kick off the task but then was
destroyed as part of the user changing device orientation. This is the reason we
added the attach() and detach() methods to FeedTask, which we now need to
make use of.
The recipe for configuration changes is:
171
Feeding at Lunch
•
Use onSaveInstanceState() and onRestoreInstanceState() for simple stuff
that can fit in the supplied Bundle
•
In onRetainNonConfigurationInstance(), return some state object for things
that cannot go in a Bundle, and update those objects as needed to indicate
that the original Activity is going away
•
In onCreate(), call getLastNonConfigurationInstance() - if that is not null,
it
is
the
object
returned
by
the
previous
call
to
onRetainNonConfigurationInstance(), and so we can hook that state back up
to the newly-created Activity
With all of that in mind, add another static inner class, this time named
InstanceState:
private static class InstanceState {
RSSFeed feed=null;
FeedTask task=null;
}
This is a simple data structure holding onto our FeedTask and the RSSFeed. These
objects are part of our state, but neither can go inside a Bundle. You should also
add an InstanceState data member named state:
private InstanceState state=null;
Then, implement the following three methods on FeedActivity:
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
state=(InstanceState)getLastNonConfigurationInstance();
if (state==null) {
state=new InstanceState();
state.task=new FeedTask(this);
state.task.execute(getIntent().getStringExtra(FEED_URL));
}
else {
if (state.task!=null) {
state.task.attach(this);
}
if (state.feed!=null) {
172
Feeding at Lunch
setFeed(state.feed);
}
}
}
@Override
public Object onRetainNonConfigurationInstance() {
if (state.task!=null)
{
state.task.detach();
}
return(state);
}
private void setFeed(RSSFeed feed) {
state.feed=feed;
setListAdapter(new FeedAdapter(feed));
}
In onCreate(), if getLastNonConfigurationInstance() is null, we must be starting up
a brand-new copy of the FeedActivity. In that case, we set up a fresh
InstanceState, a fresh FeedTask, and have the FeedTask set about downloading and
parsing our feed, using the URL we were passed in the Intent extra. If, however,
getLastNonConfigurationInstance() returns something other than null, it is the
InstanceState we are returning from onRetainNonConfigurationInstance(). In that
case, we can attach the new FeedActivity to our FeedTask, so onPostExecute() will
update our new FeedActivity when results are in. And, if we already have our
RSSFeed object, we call a setFeed() method, just like FeedTask does in
onPostExecute().
setFeed()
simply puts the RSSFeed into our InstanceState, plus wraps it in a
and puts the adapter into the ListView.
FeedAdapter
onRetainNonConfigurationInstance()
FeedTask
merely detaches the old activity from the
before returning it.
Hence, the flow of events on an orientation change is:
•
The user flicks their wrist, slides out the keyboard, or otherwise triggers
the rotation
•
onRetainNonConfigurationInstance()
from the FeedTask and returns it
173
is called, where we detach the activity
Feeding at Lunch
•
A new FeedActivity is instantiated
•
onCreate()
of the new activity is called, where we attach to the FeedTask
and, if available, use the already-parsed RSSFeed
also needs a static String data member named FEED_URL, to serve as
our Intent extra key:
FeedActivity
public static final String FEED_URL="apt.tutorial.FEEDURL";
And, we need a handful of new imports, including:
•
android.os.Bundle
•
android.view.LayoutInflater
•
android.view.View
•
android.view.ViewGroup
•
android.widget.BaseAdapter
•
android.widget.TextView
•
org.mcsoxford.rss.RSSItem
The resulting FeedActivity class, including all inner classes, should look a bit like
this:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
import
import
import
import
android.app.AlertDialog;
android.app.ListActivity;
android.os.AsyncTask;
android.os.Bundle;
android.util.Log;
android.view.LayoutInflater;
android.view.View;
android.view.ViewGroup;
android.widget.BaseAdapter;
android.widget.TextView;
org.mcsoxford.rss.RSSItem;
org.mcsoxford.rss.RSSFeed;
org.mcsoxford.rss.RSSReader;
public class FeedActivity extends ListActivity {
public static final String FEED_URL="apt.tutorial.FEEDURL";
private InstanceState state=null;
@Override
174
Feeding at Lunch
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
state=(InstanceState)getLastNonConfigurationInstance();
if (state==null) {
state=new InstanceState();
state.task=new FeedTask(this);
state.task.execute(getIntent().getStringExtra(FEED_URL));
}
else {
if (state.task!=null) {
state.task.attach(this)
;
}
if (state.feed!=null) {
setFeed(state.feed);
}
}
}
@Override
public Object onRetainNonConfigurationInstance() {
if (state.task!=null) {
state.task.detach();
}
return(state);
}
private void setFeed(RSSFeed feed) {
state.feed=feed;
setListAdapter(new FeedAdapter(feed));
}
private void goBlooey(Throwable t) {
AlertDialog.Builder builder=new AlertDialog.Builder(this);
builder
.setTitle("Exception!")
.setMessage(t.toString())
.setPositiveButton("OK", null)
.show();
}
private static class InstanceState {
RSSFeed feed=null; FeedTask
task=null;
}
private static class FeedTask extends AsyncTask<String, Void, RSSFeed> {
private RSSReader reader=new RSSReader();
private Exception e=null;
private FeedActivity activity=null;
175
Feeding at Lunch
FeedTask(FeedActivity activity) {
attach(activity);
}
void attach(FeedActivity activity) {
this.activity=activity;
}
void detach() {
this.activity=null;
}
@Override
public RSSFeed doInBackground(String... urls) {
RSSFeed result=null;
try {
result=reader.load(urls[0]);
}
catch (Exception e) {
this.e=e;
}
return(result);
}
@Override
public void onPostExecute(RSSFeed feed) {
if (e==null) {
activity.setFeed(feed);
}
else {
Log.e("LunchList","Exception parsing feed", e);
activity.goBlooey(e);
}
}
}
private class FeedAdapter extends BaseAdapter {
RSSFeed feed=null;
FeedAdapter(RSSFeed feed) {
super();
this.feed=feed;
}
@Override
public int getCount() {
return(feed.getItems().size());
}
@Override
public Object getItem(int position) {
return(feed.getItems().get(position));
176
Feeding at Lunch
}
@Override
public long getItemId(int position) {
return(position);
}
@Override
public View getView(int position, View convertView,
ViewGroup parent) { View row=convertView;
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(android.R.layout.simple_list_item_1,
parent, false);
}
RSSItem item=(RSSItem)getItem(position);
((TextView)row).setText(item.getTitle());
return(row);
}
}
}
At this point, you should be able to compile and run your application. Fill in some
likely
RSS
feed
URL
into
the
detail
form
(e.g.,
http://rss.slashdot.org/Slashdot/slashdot), and click the RSS Feed options menu
item:
177
Feeding at Lunch
Figure 32. The detail form, with an RSS feed and the options menu
That will bring up the FeedActivity, which will momentarily show you the items
in the feed:
178
Feeding at Lunch
Figure 33. FeedActivity, showing feed items
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
When the user clicks on an item in the FeedActivity's ListView, open up
the Web browser on that particular feed item.
•
The options menu item is always enabled, even if there is no feed URL
available. Use onPrepareOptionsMenu() to check to see if there is a feed URL,
then disable the FeedActivity menu item if there is no URL. Similarly,
youcan elect to disable the menu item if there is no connectivity, rather
than displaying the "sorry!" Toast as is shown above.
•
More gracefully handle various errors, such as supplying an Atom feed
URL instead ofone for an RSS feed.
•
Support multiple feed URLs (or possibly other data sources), instead of
just one.
179
Feeding at Lunch
Further Reading
Additional examples of interacting with the Internet from Android can be found in
the "Communicating via the Internet" chapter of The Busy Coder's Guide to
Android Development. More information about dealing with third-party libraries,
such as our RSS JAR, can be found in the "Leveraging Java Libraries" chapter of The
Busy Coder's Guide to Android Development.
180
TUTORIAL 16
Serving Up Lunch
In the previous tutorial, we used an AsyncTask to retrieve the contents of the RSS
feed. That was so we could get the network I/O off the main application thread,
and therefore prevent our UI from becoming sluggish or "janky".
Another way we could solve that same problem is to use an intentService. An
IntentService is a separate component that accepts commands from activities,
performs those commands on background threads, and optionally responds to the
activities or the user. In this tutorial, we will set up such an IntentService as a
replacement for the AsyncTask.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 15-Internet edition of
LunchList to use as a starting point.
Step #1: Create an Register a Stub IntentService
Add a new Java class file to the project, named FeedService.java, whereyou create
a stub implementation of an IntentService:
181
Serving Up Lunch
package apt.tutorial;
import android.app.IntentService;
import android.content.Intent;
public class FeedService extends IntentService {
public FeedService() { super("FeedService");
}
@Override
public void onHandleIntent(Intent i) {
// do something
}
}
unlike Service, requires you to implement a no-argument
constructor and chain to the superclass, supplying a name for your IntentService.
We will put some actual business logic in the implementation of onHandleIntent()
in the next step.
IntentService,
We also need to add a <service> element to the manifest, identifying this service to
Android. Your resulting AndroidManifest.xml file should look something like this:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial"
android:versionCode="1"
android:versionName="1.0">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<supports-screens
android:xlargeScreens="true
"
android:largeScreens="true"
android:normalScreens="true
"
android:smallScreens="false
"
/>
<application android:label="@string/app_name">
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" /> <category
android:name="android.intent.category.LAUNCHER" /> </intent-filter>
</activity>
<activity android:name=".DetailForm">
</activity>
<activity android:name=".EditPreferences">
182
Serving Up Lunch
</activity>
<activity android:name=".FeedActivity">
</activity>
<service android:name=".FeedService">
</service>
</application>
</manifest>
Step #2: Move Feed Fetching and Parsing to the Service
The onHandleIntent() method of IntentService will be called on a background
thread - one of the key reasons to use an IntentService. So, set up a preliminary
version of onHandleIntent() that mirror some of the logic from doInBackground()
from the FeedTask set up in the previous tutorial:
@Override
public void onHandleIntent(Intent i) {
RSSReader reader=new RSSReader();
try {
RSSFeed result=reader.load(i.getStringExtra(EXTRA_URL));
}
catch (Exception e) {
Log.e("LunchList", "Exception parsing feed", e);
}
}
All we do is load the RSS via an RSSReader and get an RSSFeed as a result. If there is
an exception, we log it.
For this to work, we need to define EXTRA_URL, the key to our Intent extra that will
identify the feed URL, so add this static data member to FeedService:
public static final String EXTRA_URL="apt.tutorial.EXTRAURL";
Also, you will need to add imports for android.util.Log, org.mcsoxford.rss.RSSFeed,
and org.mcsoxford.rss.RSSReader.
183
Serving Up Lunch
Step #3: Send the Feed to the Activity
Fetching and parsing the feed in the FeedService is all fine and well, but we need
the feed items to get to the FeedActivity. That requires a bit more work, plus a
new object: a Messenger.
A Messenger is tied to a Handler from an Activity (or, technically, any other
component that has a Handler). Just as somebody with a Handler can send
messages to the main application thread via the Handler, anyone with a Handler's
Messenger can send messages to the Handler. These are "handled" the same as any
other Handler messages, via handleMessage(). And, the beauty of a Messenger is that
it implements the Parcelable interface, and so can be packaged in an Intent extra
as easily as can a String.
So, we will require that FeedActivity supply us with a Messenger that we can use to
send results back to the FeedActivity itself.
With that in mind, update onHandleIntent() in FeedService to look like this:
@Override
public void onHandleIntent(Intent i) {
RSSReader reader=new RSSReader();
Messenger messenger=(Messenger)i.getExtras().get(EXTRA_MESSENGER);
Message msg=Message.obtain();
try {
RSSFeed result=reader.load(i.getStringExtra(EXTRA_URL));
msg.arg1=Activity.RESULT_OK;
msg.obj=result;
}
catch (Exception e) {
Log.e("LunchList", "Exception parsing feed", e);
msg.arg1=Activity.RESULT_CANCELED;
msg.obj=e;
}
try {
messenger.send(msg);
}
catch (Exception e) {
Log.w("LunchList", "Exception sending results to activity", e);
}
}
184
Serving Up Lunch
Here, we get a Messenger object out of our Intent extras, keyed by an
EXTRA_MESSENGER key. We then get an empty Message object from the Messenger. If
the fetch-and-parse of the RSS feed succeeds, we put RESULT_OK in the arg1 public
data member of the Message and put the RSSFeed in the obj public field of the
Message. If an Exception is raised, we set arg1 to RESULT_CANCELED and obj to be the
Exception.
Then, we tell the Messenger to send() the Message. If the activity is still on the
screen - or if we handle configuration changes properly - this will succeed without
incident. If, however, the activity has been permanently destroyed, such as by the
user pressing BACK, we will get an exception, which we simply log as a warning.
For this to compile, we need to add a definition for EXTRA_MESSENGER:
public static final String EXTRA_MESSENGER="apt.tutorial.EXTRA_MESSENGER";
We also need to add four more imports:
•
android.app.Activity
•
android.os.Message
•
android.os.Messenger
•
org.mcsoxford.rss.RSSItem
The complete implementation of FeedService, therefore, should look a bit like this:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
android.app.Activity;
android.app.IntentService;
android.content.Intent;
android.os.Message;
android.os.Messenger;
android.util.Log;
org.mcsoxford.rss.RSSItem;
org.mcsoxford.rss.RSSFeed;
org.mcsoxford.rss.RSSReader;
public class FeedService extends IntentService {
public static final String EXTRA_URL="apt.tutorial.EXTRAURL";
public static final String EXTRA_MESSENGER="apt.tutorial.EXTRA_MESSENGER";
185
Serving Up Lunch
public FeedService() {
super("FeedService");
}
@Override
public void onHandleIntent(Intent i) {
RSSReader reader=new RSSReader();
Messenger messenger=(Messenger)i.getExtras().get(EXTRA_MESSENGER);
Message msg=Message.obtain();
try {
RSSFeed result=reader.load(i.getStringExtra(EXTRA_URL));
msg.arg1=Activity.RESULT_OK;
msg.obj=result;
}
catch (Exception e) {
Log.e("LunchList", "Exception parsing feed", e);
msg.arg1=Activity.RESULT_CANCELED;
msg.obj=e;
}
try {
messenger.send(msg);
}
catch (Exception e) {
Log.w("LunchList", "Exception sending results to activity", e);
}
}
}
Step #4: Display the Feed Items, Redux
Now we need to make the requisite changes to FeedActivity to work with
FeedService instead of FeedTask.
We can start byconverting FeedTask to FeedHandler, having itextend Handler
instead of AsyncTask. We can retain the attach() and detach() methods, as we will
need those for handling configuration changes. The doInBackground() method can
be removed, as that logic is now handled by FeedService. The onPostExecute()
method turns into a handleMessage() method, to take the Message object from
FeedService and either call setFeed() or goBlooey() on FeedActivity, depending
onwhetherwe received RESULT_OK or RESULT_CANCELED in the Message.
186
Serving Up Lunch
The resulting FeedHandler would look like this:
private static class FeedHandler extends Handler {
FeedActivity activity=null;
FeedHandler(FeedActivity activity) {
attach(activity);
}
void attach(FeedActivity activity) {
this.activity=activity;
}
void detach() {
this.activity=null;
}
@Override
public void handleMessage(Message msg) {
if (msg.arg1==RESULT_OK) {
activity.setFeed((RSSFeed)msg.obj);
}
else {
activity.goBlooey((Exception)msg.obj);
}
}
}
Since we no longer have FeedTask, we no longer need it in InstanceState.
However, we do need to hold onto our Handler as part of our state, so when the
user rotates the screen, our Messenger object can still communicate with the right
FeedActivity. Hence, replace the FeedTask with FeedHandler in InstanceState:
private static class InstanceState {
RSSFeed feed=null; FeedHandler
handler=null;
}
This means that onRetainNonConfigurationInstance() needs
accommodate the switch between task and handler:
@Override
public Object onRetainNonConfigurationInstance() {
if (state.handler!=null) {
state.handler.detach();
}
187
to
change, to
Serving Up Lunch
return(state);
}
Also, our onCreate() method needs to have a few changes:
•
If getLastNonConfigurationInstance() is null, when we create the fresh
InstanceState, we also call startService() on our FeedService, to request
that it fetch and parse the RSS feed
•
If getLastNonConfigurationInstance() is not null, we need to attach the
new FeedActivity to the handler, not the task as before
The resulting onCreate() method would look like:
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
state=(InstanceState)getLastNonConfigurationInstance();
if (state==null) {
state=new InstanceState();
state.handler=new FeedHandler(this);
Intent i=new Intent(this, FeedService.class);
i.putExtra(FeedService.EXTRA_URL
getIntent().getStringExtra(FEED_URL));
i.putExtra(FeedService.EXTRA_MESSENGER,
new Messenger(state.handler));
startService(i);
}
else {
if (state.handler!=null) {
state.handler.attach(this);
}
if (state.feed!=null) {
setFeed(state.feed);
}
}
}
Everything else can remain the same, other than replacing some imports (e.g.,
AsyncTask with android.os.Handler), removing the import for RSSReader, and
addingsome other imports:
188
Serving Up Lunch
android.content.Intent
android.os.Handler
android.os.Message
android.os.Messenger
The entire FeedActivity implementation should resemble:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
android.app.AlertDialog;
android.app.ListActivity;
android.content.Intent;
android.os.Bundle;
android.os.Handler;
android.os.Message;
android.os.Messenger;
android.view.LayoutInflater;
android.view.View;
android.view.ViewGroup;
android.widget.BaseAdapter;
android.widget.TextView;
org.mcsoxford.rss.RSSItem;
org.mcsoxford.rss.RSSFeed;
public class FeedActivity extends ListActivity {
public static final String FEED_URL="apt.tutorial.FEEDURL";
private InstanceState state=null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
state=(InstanceState)getLastNonConfigurationInstance();
if (state==null) {
state=new InstanceState();
state.handler=new FeedHandler(this);
Intent i=new Intent(this, FeedService.class);
i.putExtra(FeedService.EXTRA_URL,
getIntent().getStringExtra(FEEDURL));
i.putExtra(FeedService.EXTRA_MESSENGER,
new Messenger(state.handler));
startService(i);
}
else {
if (state.handler!=null) {
state.handler.attach(this);
}
189
Serving Up Lunch
if (state.feed!=null)
{
setFeed(state.feed);
}
}
}
@Override
public Object onRetainNonConfigurationInstance() {
if (state.handler!=null) {
state.handler.detach();
}
return(state);
}
private void setFeed(RSSFeed feed) {
state.feed=feed;
setListAdapter(new FeedAdapter(feed));
}
private void goBlooey(Throwable t) {
AlertDialog.Builder builder=new AlertDialog.Builder(this);
builder
.setTitle("Exception!")
.setMessage(t.toString())
.setPositiveButton("OK", null)
.show();
}
private static class InstanceState {
RSSFeed feed=null; FeedHandler
handler=null;
}
private class FeedAdapter extends BaseAdapter {
RSSFeed feed=null;
FeedAdapter(RSSFeed feed) {
super();
this.feed=feed;
}
@Override
public int getCount() {
return(feed.getItems().size());
}
@Override
public Object getItem(int position) {
return(feed.getItems().get(position));
}
190
Serving Up Lunch
@Override
public long getItemId(int position) {
return(position);
}
@Override
public View getView(int position, View convertView,ViewGroup
parent){
View row=convertView;
if (row==null) {
LayoutInflater inflater=getLayoutInflater();
row=inflater.inflate(android.R.layout.simple_list_item_1,
parent, false);
}
RSSItem item=(RSSItem)getItem(position);
((TextView)row).setText(item.getTitle());
return(row);
}
}
private static class FeedHandler extends Handler {
FeedActivity activity=null;
FeedHandler(FeedActivity activity) {
attach(activity);
}
void attach(FeedActivity activity) {
this.activity=activity;
}
void detach() {
this.activity=null;
}
@Override
public void handleMessage(Message msg) {
if (msg.arg1==RESULT_OK) {
activity.setFeed((RSSFeed)msg.obj);
}
else {
activity.goBlooey((Exception)msg.obj);
}
}
}
}
191
Serving Up Lunch
If you compile and run the new LunchList, nothing changes visibly. The user
experience is identical.
So why bother with an IntentService?
In this case, perhaps it is not necessary. The big advantage of an IntentService,
though, is that it can live beyond the scope of any activity. Suppose instead of
downloading an RSS feed, we were downloading a PDF of a book that the user
bought. We should not force the user to have to wait in our activity for the
download to complete, yet if the activity is destroyed, any threads it forked may be
killed off as well. The IntentService, on the other hand, can continue
downloading, and it will automatically destroy itself when onHandleIntent() ends.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
To confirm that our configuration handling works properly, add a call to
sleep() on android.os.SystemClock in the FeedService, somewhere in
onHandleIntent() before calling send() on the Messenger. While the service
is asleep, you can rotate the screen of your device or emulator, and
confirm that the message still makes it to the new FeedActivity instance.
•
Experiment with other ways of having the FeedService send results to the
FeedActivity, such as via a broadcast Intent, the PendingIntent created by
calling createPendingResult() on an Activity, or a ResultReceiver.
•
Experiment with having the FeedService go ahead and download/parse the
RSS feed when the DetailsForm comes up, rather than waiting for the user
to start the FeedActivity. This will require having some way of caching the
results, such that you can make them available to the FeedActivity upon
demand. You may find that it is simpler to do the download and the
parsing in separate steps, caching the downloaded feed (pre-fetched when
192
Serving Up Lunch
DetailsForm
FeedActivity
comes up) and parsing the cached feed only when
requests it.
Further Reading
You can learn more about the roles of services and how to create them in the
"Creating a Service" chapter of The Busy Coder's Guide to Android Development.
193
194
TUTORIAL 17
Locating Lunch
While we keep track of the address of our restaurants, it might also be useful to
keep track of the GPS coordinates as well. In this tutorial, we will hook up to the
LocationManager system service and find a restaurant's location via GPS, saving it in
the database for later use.
WARNING: The Android 2.3 emulator has bugs related to simulating locations
using DDMS. For this tutorial, you will need to use another emulator or a pieceof
hardware. The Android 2.3 problem is limited to the emulator - using a device's
actual GPS should pose no problems, assuming you are someplace where you can
get a GPS signal.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 16-Services edition of
LunchList to use as a starting point.
Step #1: Add Latitude and Longitude to the Data Model
Two tutorials ago, we modified our database and RestaurantHelper to add support
for a feed URL. Now, we get to make more changes, to store the latitude and
longitude of a restaurant.
195
Locating Lunch
So, add in a pair of REAL columns named lat and lon to the schema used in
onCreate() ofRestaurantHelper:
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE restaurants (_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,
address TEXT, type TEXT, notes TEXT, feed TEXT, lat REAL, lon REAL);"); }
This will also require incrementing our SCHEMA_VERSION to 3:
private static final int SCHEMA_VERSION=3;
Modifying onUpgrade() in RestaurantHelper, though, becomes a bit trickier. Many
users of our app will be on SCHEMA_REVISION 2 when they install our new copy of
the application. However, it is possible that some users skipped upgrading
LunchList along the way and are still back on SCHEMA_REVISION 1. As such, we
need to handle upgrading 1-> 3 and 2->3, not just the latter. A typical solution for
this is to do the upgrades in series, 1->2 where needed, then 2->3.
With that in mind, modify onUpgrade() to do our original ALTER TABLE for the feed
column if the SCHEMA_REVISION is less than 2, plus add a new stanza to add our
lat and lon columns if we are less than SCHEMA_REVISION 3:
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { if
(oldVersion<2){
db.execSQL("ALTER TABLE restaurants ADD COLUMN feed TEXT");
}
if (oldVersion<3) {
db.execSQL("ALTER TABLE restaurants ADD COLUMN lat REAL");
db.execSQL("ALTER TABLE restaurants ADD COLUMN lon REAL");
}
}
Our two RestaurantHelper query methods, getAll() and getById(), will also need
to start returning the lat and lon columns:
public Cursor getAll(String orderBy) {
return(getReadableDatabase()
196
Locating Lunch
.rawQuery("SELECT _id, restaurants
ORDER BY "+orderBy, null));
}
public Cursor getById(String id)
String[] args={id};
return(getReadableDatabase()
.rawQuery("SELECT _id,
restaurants name, address, type,
notes, feed, lat, lon FROM WHERE
ID=?",args));
}
name,
address,
type,
notes,
lat, lon FROM
{
However, the user will not be modifying the location directly - expecting
somebody to manually type in a latitude and longitude is probably asking too
much. Later on, we will use an options menu item to allow the user to request a
location via GPS. Hence, we do not need to worry about modifying insert() and
update() in RestaurantHelper, as we will never be setting or changing the latitude
and longitude when we call them. Rather, we need a new method in
RestaurantHelper - call it updateLocation() - that will do a SQL UPDATE statement to
put the latitude and longitude in a restaurant's row:
public void updateLocation(String id, double lat, double lon) {
ContentValues cv=new ContentValues(); String[] args={id};
cv.put("lat", lat);
cv.put("lon", lon);
getWritableDatabase().update("restaurants", cv, "_ID=?",
args);
}
This, of course, assumes that our restaurant already exists in the database, a
restriction we will need to enforce in the UI.
Finally, we need a couple of getter methods in RestaurantHelper to return the
latitude and longitude from a Cursor returned by getAll() or getByid():
public double getLatitude(Cursor c) {
return(c.getDouble(6));
}
197
Locating Lunch
public double getLongitude(Cursor c) {
return(c.getDouble(7));
}
The revised RestaurantHelper should resemble:
package apt.tutorial;
import
import
import
import
import
import
import
android.content.Context;
android.content.ContentValues;
android.database.Cursor;
android.database.SQLException;
android.database.sqlite.SQLiteOpenHelper;
android.database.sqlite.SQLiteDatabase;
android.database.sqlite.SQLiteQueryBuilder;
class RestaurantHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME="lunchlist.db";
private static final int SCHEMA_VERSION=3;
public RestaurantHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE restaurants (_id INTEGER PRIMARY KEY AUTOINCREMENT, name
TEXT, address TEXT, type TEXT, notes TEXT, feed TEXT, lat REAL, lon REAL);");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
if (oldVersion<2) {
db.execSQL("ALTER TABLE restaurants ADD COLUMN feed TEXT");
}
if (oldVersion<3) {
db.execSQL("ALTER TABLE restaurants ADD COLUMN lat REAL");
db.execSQL("ALTER TABLE restaurants ADD COLUMN lon REAL");
}
}
public Cursor getAll(String orderBy) {
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes, lat, lon FROM restaurants ORDER BY
"+orderBy, null));
}
public Cursor getById(String id) {
String[] args={id};
198
Locating Lunch
return(getReadableDatabase()
.rawQuery("SELECT _id, name, address, type, notes, feed, lat, lon FROM restaurants
WHERE _ID=?", args));
}
public void insert(String name, String address, String
type, String notes, String feed) {
ContentValues cv=new ContentValues();
cv.put("name", name);
cv.put("address", address);
cv.put("type", type);
cv.put("notes", notes);
cv.put("feed", feed);
getWritableDatabase().insert("restaurants", "name", cv);
}
public void update(String id, String name, String address, String type,
String notes, String feed) {
ContentValues cv=new ContentValues(); String[] args={id};
cv.put("name", name);
cv.put("address", address);
cv.put("type", type);
cv.put("notes", notes);
cv.put("feed", feed);
getWritableDatabase().update("restaurants", cv, "_ID=?"
args);
}
public void updateLocation(String id, double lat, double lon) {
ContentValues cv=new ContentValues(); String[] args={id};
cv.put("lat",
lat);
cv.put("lon", lon);
getWritableDatabase().update("restaurants", cv, "_ID=?"
args);
}
public String getName(Cursor c) {
return(c.getString(1));
}
public String getAddress(Cursor c) {
return(c.getString(2));
}
public String getType(Cursor c) {
199
Locating Lunch
return(c.getString(3));
}
public String getNotes(Cursor c) {
return(c.getString(4));
}
public String getFeed(Cursor c) {
return(c.getString(5));
}
public double getLatitude(Cursor c) {
return(c.getDouble(6));
}
public double getLongitude(Cursor c) {
return(c.getDouble(7));
}
}
Step #2: Save the Restaurant in onPause()
We need to add a spot for displaying the GPS coordinates on the screen. Once
again, we are running out of room.
One big chunk of screen space is taken up with our Save button. Most Android
activities do not have such a button. Instead, they take one of two approaches:
1.
There is an options menu item to save
2.
The data is saved automatically when the activity is paused
Here, let's try the second approach - save the restaurant to the database when the
activity is paused, such as the user pressing BACK or HOME.
To do this, first get rid of all references to the "save" Button from the DetailForm
class. You can also get rid of the android.widget.Button import, which may help you
determine what you need to get rid of.
Then, in the DetailForm class, convert the onSave OnItemClickListener object to a
save() method, where that method just does what onClick() used to to in the
onSave object:
200
Locating Lunch
private void save() {
String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break; case
R.id.take_out:
type="take_out";
break;
default:
type="delivery";
break;
}
if (restaurantid==null) {
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toString());
}
else {
helper.update(restaurantid, name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toString());
}
finish();
}
Then, add an implementation of onPause() to DetailForm that calls save():
@Override
public void onPause() {
save();
super.onPause();
}
Step #3: Add a TextView and Options Menu Item for
Location
Given that we have made the Save button obsolete, we can remove it from our
layouts, putting in place a spot to display the GPS coordinates (when we have
them). We also need to allow the user to request a location fix from GPS, and the
easiest way to do that is to add another options menu item.
201
Locating Lunch
In res/layout/detail_form.xml, remove the Save button and add in another
TableRow that has two TextView widgets, one with a "Location:" caption and one
(named location) that will hold our actual GPS coordinates. The resulting layout
file should looksomething like this:
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="1" >
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name" />
</TableRow>
<TableRow>
<TextView android:text="Address:" />
<EditText android:id="@+id/addr" />
</TableRow>
<TableRow>
<TextView android:text="Type:" />
<RadioGroup android:id="@+id/types">
<RadioButton android:id="@+id/take_out"
android:text="Take Out"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
</TableRow>
<TableRow>
<TextView android:text="Location:" />
<TextView android:id="@+id/location" android:text="(not set)" />
</TableRow>
<EditText android:id="@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="2"
android:scrollHorizontally="false"
android:maxLines="2"
android:maxWidth="200sp"
android:layout_span="2"
android:hint="Notes"
android:layout_marginTop="4dip"
/>
<EditText android:id="@+id/feed"
android:layout_span="2"
android:hint="Feed URL"
/>
</TableLayout>
202
Locating Lunch
Similarly, in res/layout-land/detail_form.xml, replace the Save button with a
nested horizontal LinearLayout holding onto the same two TextView widgets:
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:stretchColumns="2" >
<TableRow>
<TextView android:text="Name:" />
<EditText android:id="@+id/name"
android:layout_span="2"
/>
</TableRow>
<TableRow>
<TextView android:text="Address:" />
<EditText android:id="@+id/addr"
android:layout_span="2"
/>
</TableRow>
<TableRow>
<TextView android:text="Type:" /> <RadioGroup
android:id="@+id/types"> <RadioButton
android:id="@+id/take_out"
android:text="TakeOut"
/>
<RadioButton android:id="@+id/sit_down"
android:text="Sit-Down"
/>
<RadioButton android:id="@+id/delivery"
android:text="Delivery"
/>
</RadioGroup>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical"
>
<EditText android:id="@+id/notes"
android:singleLine="false"
android:gravity="top"
android:lines="4"
android:scrollHorizontally="false"
android:maxLines="4"
android:maxWidth="140sp"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:hint="Notes"
/>
<EditText android:id="@+id/feed"
android:layout_width="fill_parent"
android:layout height="wrap content"
203
Locating Lunch
android:hint="Feed URL"
/>
<LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="horizontal" >
<TextView android:text="Location:"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>
<TextView android:id="@+id/location"
android:text="(not set)"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>
</LinearLayout>
</LinearLayout>
</TableRow>
</TableLayout>
In DetailForm, add in a data member for the location TextView:
TextView location=null;
Also, we need to retrieve that widget in the onCreate() method of DetailForm, as we
have with the other widgets we modify:
location=(TextView)findViewById(R.id.location);
Then, in the load() method of DetailForm, we can get our latitude and longitude
from RestaurantHelper and pour them into the TextView:
private void load() {
Cursor c=helper.getById(restaurantId);
c.moveToFirst();
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
notes.setText(helper.getNotes(c));
feed.setText(helper.getFeed(c));
if (helper.getType(c).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(c).equals("take_out")) {
types.check(R.id.take_out);
}
else {
204
Locating Lunch
types.check(R.id.delivery);
}
location.setText(String.valueOf(helper.getLatitude(c))
+String.valueOf(helper.getLongitude(c)));
c.close();
}
We
also
need
to
add a location options menu item to our
res/menu/details_option.xml file, for the user to request collecting the GPS location
for the restaurant. Modify that file to resemble:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/feed"
android:title="RSS Feed"
android:icon="@drawable/ic_menu_friendslist"
/>
<item android:id="@+id/location"
android:title="Save Location"
android:icon="@drawable/ic_menu_compass"
/>
</menu>
You will also need an icon to go with the menu item, such as ic_menu_compass. png
from the Android SDK.
Step #4: Update the Permissions
To use GPS, we will need to add the ACCESS_FINE_LOCATION permission to our
AndroidManifest.xml file. The resulting file should look a bit like:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial" android:versionCode="1"
android:versionName="1.0">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION"
<supports-screens
android:xlargeScreens="true"
android:largeScreens="true"
android:normalScreens="true"
android:smallScreens="false"
205
/>
Locating Lunch
/>
application android:label="@string/app_name">
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intentfilter> </activity>
<activity android:name=".DetailForm">
</activity>
<activity android:name=".EditPreferences">
</activity>
<activity android:name=".FeedActivity">
</activity>
<service android:name=".FeedService"> </service>
</application>
</manifest>
Step #5: Find Our Location Using GPS
Now, we need to actually figure out where we are, when the user asks. Since the
GPS radio is normally not on, to save power, we cannot just ask Android, "hey,
where are we?" Instead, we will need to request location updates, long enough to
get a fix.
First, add a data member to DetailForm for LocationManager, the system service that
is our gateway to location information:
LocationManager locMgr=null;
Next, we need to initialize this data member by calling getSystemService(), asking
for the LOCATION_SERVICE. onCreate() of DetailForm is a likely place to do this, so
add that call somewhere in onCreate():
locMgr=(LocationManager)getSystemService(LOCATION_SERVICE);
Then, we need to detect when the user taps our location options menu item. What
we can do is ask the LocationManager to turn on GPS and start fetching fixes, letting
us know when they arrive. This is done via the requestLocationUpdates() method.
So, amend the onOptionsItemSelected() method in DetailsForm to add in the
requestLocationUpdates() call:
206
Locating Lunch
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.feed) {
if (isNetworkAvailable()) {
Intent i=new Intent(this, FeedActivity.class);
i.putExtra(FeedActivity.FEED_URL,feed.getText().toString());
startActivity(i);
}
else {
Toast
.makeText(this, "Sorry, the Internet is not available",
Toast.LENGTH_LONG)
.show();
}
return(true);
}
else if (item.getItemId()==R.id.location) {
locMgr.requestLocationUpdates(LocationManager.GPS_PROVIDER,
0, 0, onLocationChange);
return(true);
}
return(super.onOptionsItemSelected(item));
}
The second and third parameters to requestLocationUpdates() are the desired
frequency of updates and the minimum distance moved to let us know of a
position change - we set these both to zero, so we get fixes as soon as theyarrive.
The fourth parameter is a LocationListener object, here named onLocationChange,
which will be called with onLocationChanged() when GPS fixes arrive. When a GPS
fix arrives, we need to:
•
Update the UI with the GPS coordinates
•
Save those GPS coordinates in the database for this restaurant
•
Stop requesting updates, since we only need the one
With that in mind, add the onLocationChange data member to DetailForm:
LocationListener onLocationChange=new LocationListener() {
public void onLocationChanged(Location fix) {
helper.updateLocation(restaurantId, fix.getLatitude(),
fix.getLongitude());
location.setText(String.valueOf(fix.getLatitude())
207
Locating Lunch
+String.valueOf(fix.getLongitude()));
locMgr.removeUpdates(onLocationChange);
Toast
.makeText(DetailForm.this, "Location saved",
Toast.LENGTH_LONG)
.show();
}
public void onProviderDisabled(String provider) {
// required for interface, not used
}
public void onProviderEnabled(String provider) {
// required for interface, not used
}
public void onStatusChanged(String provider, int status,
Bundle extras) {
// required for interface, not used
}
};
Note that we also display a Toast, just to let the user know that we successfully
collected the location. There are other methods on LocationListener that, for the
purposes of this tutorial, we will ignore.
However, it is possible that the user will have left the activity while we are still
waiting on a GPS fix. In that case, it is safest to abandon the GPS request otherwise, we may leave the GPS radio on indefinitely, particularly if we are in a
large building where we cannot get a GPS fix. So, amend onPause() in DetailForm to
remove our request for updates:
@Override
public void onPause() {
save();
locMgr.removeUpdates(onLocationChange);
super.onPause();
}
ou will also need to add imports for:
•
android.location.Location
•
android.location.LocationListener
•
android.location.LocationManager
208
Locating Lunch
Step #6: Only Enable Options Menu Item If Saved
The updateLocation() method on RestaurantHelper does a SQL UPDATE to add our
latitude and longitude to a restaurant. However, this only works if the restaurant
exists in the database. Right now, it is possible for the user to start adding a new
restaurant, then request saving the GPS coordinates -that will not work.To combat
this threat, we should disable the location options menu item if the restaurant is
not saved in the database. We can tell whether or not it is saved by checking to see
if restaurantid - the key of our restaurant - is null or not. A non-null restaurantid
means the restaurant exists in the database.
One way to make this change is to add an onPrepareOptionsMenu() method to
DetailForm, such as this one:
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (restaurantId==null) {
menu.findItem(R.id.location).setEnabled(false);
}
return(super.onPrepareOptionsMenu(menu));
}
Here, we retrieve the menu item and disable it if restaurantId is null.
onPrepareOptionsMenu() is called every time the MENU button is pressed, not just
the first time.
The entire DetailForm class, incorporating all changes in this tutorial, should look
something like this:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
import
android.app.Activity;
android.content.Intent;
android.database.Cursor;
android.location.Location;
android.location.LocationListener;
android.location.LocationManager;
android.net.ConnectivityManager;
android.net.Networklnfo;
android.os.Bundle;
android.view.Menu;
209
Locating Lunch
import
import
import
import
import
import
import
android.view.Menulnflater;
android.view.Menultem;
android.view.View;
android.widget.EditText;
android.widget.RadioGroup;
android.widget.TextView;
android.widget.Toast;
public class DetailForm extends Activity {
EditText name=null; EditText address=null;
EditText notes=null; EditText feed=null;
RadioGroup types=null; RestaurantHelper
helper=null; String restaurantId=null;
TextView location=null; LocationManager
locMgr=null;
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.detail_form);
locMgr=(LocationManager)getSystemService(LOCATION_SERVICE);
helper=new RestaurantHelper(this);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
feed=(EditText)findViewById(R.id.feed);
location=(TextView)findViewById(R.id.location);
restaurantId=getIntent().getStringExtra(LunchList.ID_EXTRA);
if (restaurantId!=null) {
load();
}
}
@Override
public void onPause() {
save();
locMgr.removeUpdates(onLocationChange);
super.onPause();
}
@Override
public void onDestroy() {
helper.close();
super.onDestroy();
210
Locating Lunch
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.details_option, menu);
return(super.onCreateOptionsMenu(menu));
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (restaurantId==null) {
menu.findItem(R.id.location).setEnabled(false);
}
return(super.onPrepareOptionsMenu(menu));
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.feed) { if (isNetworkAvailable()) {
Intent i=new Intent(this, FeedActivity.class);
i.putExtra(FeedActivity.FEED_URL,feed.getText().toString());
startActivity(i);
}
else {
Toast
.makeText(this, "Sorry, the Internet is not available",
Toast.LENGTH_LONG)
.show();
}
return(true);
}
else if (item.getItemId()==R.id.location) {
locMgr.requestLocationUpdates(LocationManager.GPS_PROVIDER,
0, 0, onLocationChange);
return(true);
}
return(super.onOptionsItemSelected(item));
}
private boolean isNetworkAvailable() { ConnectivityManager
cm=(ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);
Networklnfo info=cm.getActiveNetworkInfo();
return(info!=null);
}
211
Locating Lunch
private void load() {
Cursor c=helper.getById(restaurantId);
c.moveToFirst();
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
notes.setText(helper.getNotes(c));
feed.setText(helper.getFeed(c));
if (helper.getType(c).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(c).equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
location.setText(String.valueOf(helper.getLatitude(c))
+String.valueOf(helper.getLongitude(c)));
c.close();
}
private void save() {
String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break; case
R.id.take_out:
type="take_out";
brea
k;
defaul
t:
type="delivery";
break;
}
if (restaurantId==null) {
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toSt ring());
}
else {
helper.update(restaurantId, name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toSt ring());
}
212
Locating Lunch
finish();
}
LocationListener onLocationChange=new LocationListener() {
public void onLocationChanged(Location fix) {
helper.updateLocation(restaurantId, fix.getLatitude(),
fix.getLongitude());
location.setText(String.valueOf(fix.getLatitude())
+","
+String.valueOf(fix.getLongitude()));
locMgr.removeUpdates(onLocationChange);
Toast
.makeText(DetailForm.this, "Location saved",
Toast.LENGTH_LONG)
.show();
}
public void onProviderDisabled(String provider) {
// required for interface, not used
}
public void onProviderEnabled(String provider) {
// required for interface, not used
}
public void onStatusChanged(String provider, int status,
Bundle extras) {
// requiredfor interface, notused
}
};
}
At this point, if you compile and install the application, on the detail form, you
will see a place for the restaurant GPS coordinates:
213
Locating Lunch
Figure 34. The detail form, with default GPS coordinates
Pressing the MENU button will bring up the new options menu item:
214
Locating Lunch
Figure 35. The detail form and its new options menu
To test it, if you are running it on actual hardware, just tap the menu item and
wait for the Toast to appear. If you are running the application on an emulator,
you will need to use DDMS to send a fake GPS fix, after tapping the menu item to
"turn on the GPS radio", as it were. The Emulator Controls tab of DDMS will have
a spot for you to supply a longitude and latitude, plus a Send button to push the
fake fix over to LunchList.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Use the Criteria object to remove the hard-wired dependency on GPS.
However, in this case, we would still want ACCURACY_FINE locations - we
are trying to fix the position of a restaurant, which would be useless if off
by half a kilometer or more.
•
Tie into a geocoding service to allow the user to fill in the address of the
restaurant from the GPS coordinates, rather than having to ask somebody,
let alone having to type it in. Note that while Android
215
Locating Lunch
has a Geocoder, it appears to be somewhat buggy, so while you are
welcome to experiment with it, do not be shocked if you encounter some
problems.
Add a "reset" or "revert" options menu item that allows the user to restore
the values that are in the database, in case they made edits and do not
want to save them. If the restaurant is not in the database (i.e., has never
been saved), this options menu item should blank the detail form.
If you have not added options for deleting a restaurant, this might be a
good time. After all, if the user accidentally taps on the add options menu
item in the LunchList activity, they are forced to save a restaurant in
ourcurrent UI. Add a "delete" options menu item on DetailForm (preferably
with an AlertDialog for confirmation) and/or a "delete" context menu item
on LunchList itself.
Since the restaurant is either in or not in the database at the start of
DetailForm, and that state does not change while the activity is onscreen,
we would not need to use onPrepareOptionsMenu() - we could disable the
menu item in onCreateOptionsMenu(), after inflating the menu. Make this
change and experiment with the results.
Further Reading
Location tracking, via GPS or other technologies, is covered in the "Accessing
Location-Based Services" chapter of The Busy Coder's Guide to Android
Development.
216
TUTORIAL 18
Putting Lunch on the Map
Now that we have GPS coordinates for our restaurants, it might be useful to show
where those locations are on a map, so that the user can remember how to get
there. The simple way do to that would be to launch the built-in maps application,
via a geo: URL and an ACTION_VIEW Intent. However, we cannot draw a marker
on that sort of map, which might be interesting. So, here, we will do things the
hard way, by integrating MapActivity and MapView into LunchList.
NOTE: You will need to register for an API key to use with the mapping services
and set it up in your development environment with your debug certificate. Full
instructions for doing this can be found on the Android developer site. You will
also need to be testing on an AVD or device that has Google Maps installed.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 17-Location edition of
LunchList to use as a starting point.
217
Putting Lunch on the Map
Step #1: Add an Options Menu Item for Map
First, we need to give the user a way to request a map of the restaurant. The
simplest solution: add another options menu item. So, add a map <item> element to
the res/menu/details_option.xml file:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/feed" android:title="RSS Feed"
android:icon="@drawable/ic_menu_friendslist"
/>
<item android:id="@+id/location"
android:title="Save Location"
android:icon="@drawable/ic_menu_compass"
/>
<item android:id="@+id/map"
android:title="Show on Map"
android:icon="@drawable/ic_menu_mapmode"
/>
</men
u>
You will need an icon for this as well, perhaps the ic_menu_mapmode.png file from the
Android SDK.
Also, modify onPrepareOptionsMenu() in DetailForm to disable this menu item if the
restaurant is not saved (and therefore definitely lacks a location):
@Override
public boolean onPrepareOptionsMenu(Menu menu) { if
(restaurantId==null) {
menu.findItem(R.id.location).setEnabled(false);
menu.findItem(R.id.map).setEnabled(false);
}
return(super.onPrepareOptionsMenu(menu));
}
Step #2: Create and Use a MapActivity
Next, let us integrate a basic MapActivity.
218
Putting Lunch on the Map
First, we need to tell Android that we intend to use the Google Maps capability.
This is accomplished via a <uses-library> element in the manifest, indicating that
we plan to use com.google.android.maps. This will cause that firmware library to be
loaded into our process when the application starts up, and it makes classes like
MapActivity available to us.
So, modify AndroidManifest.xml to add the <uses-library> element, plus another
<activity> element, this time for a RestaurantMap class that we will create shortly:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial"
android:versionCode="1"
android:versionName="1.0">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<supports-screens
android:xlargeScreens="true
"
android:largeScreens="true"
android:normalScreens="true
"
android:smallScreens="false
"
/>
<application android:label="@string/app_name">
<uses-library android:name="com.google.android.maps" />
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".DetailForm">
</activity>
<activity android:name=".EditPreferences">
</activity>
<activity android:name=".FeedActivity">
</activity>
<activity android:name=".RestaurantMap">
</activity>
<service android:name=".FeedService">
</service>
</application>
</manifest>
Next, add a rudimentary RestaurantMap class to the LunchList project, in the
apt.tutorial package, inheriting from MapActivity, and loading in the
219
Putting Lunch on the Map
R.layout.map layout resource. In addition to onCreate(), the initial cut of
RestaurantMap will need to override isRouteDisplayed(), as that is an abstract
method - just return false. Here is what this class should look like at the outset:
package apt.tutorial;
import android.os.Bundle;
import com.google.android.maps.MapActivity;
public class RestaurantMap extends MapActivity {
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.map);
}
@Override
protected boolean isRouteDisplayed() {
return(false);
}
}
Now, we need to tie that into the DetailForm class, so when the user clicks on the
map options menu item, we launch RestaurantMap. That is merely a matter of
adding another condition to onOptionsItemSelected() and calling startActivity():
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.feed) {
if (isNetworkAvailable()) {
Intent i=new Intent(this, FeedActivity.class);
i.putExtra(FeedActivity.FEED_URL,feed.getText().toString());
startActivity(i);
}
else {
Toast
.makeText(this, "Sorry, the Internet is not available",
Toast LENGTH_LONG)
.show();
}
return(true);
}
else if (item.getItemId()==R.id.location) {
locMgr.requestLocationUpdates(LocationManager.GPS_PROVIDER,
0, 0, onLocationChange);
220
Putting Lunch on the Map
return(true);
}
else if (item.getItemId()==R.id.map) {
Intent i=new Intent(this, RestaurantMap.class);
startActivity(i);
return(true);
}
return(super.onOptionsItemSelected(item));
}
We also need a layout file, res/layout/map.xml. It can just be a full-screen MapView.
However, there are three tricks:
1.
Because MapView is not part of android.widget, you must fully-qualify it as
com.google.android.maps.MapView
2.
You will need to have an android:apiKey attribute containing your API key
3.
You probably want to have android:clickable="true", so the user can pan
and zoom around the map by themselves
Here is a layout file that fits those requirements (though you will need to replace
the API key shown here with your own):
<?xml version="1.0" encoding="utf-8"?>
<com.google.android.maps.MapView
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/map"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:apiKey="00yHj0k7_7vxbuQ9zwyXI4bNMJrAjYrJ9KKHgbQ"
android:clickable="true"
/>
Step #3: Create an ItemizedOverlay
If we want to display a marker where the restaurant is, we are going to need to get
our latitude and longitude to the RestaurantMap, then use thatwithan
ItemizedOverlay to render our marker.
221
Putting Lunch on the Map
To get the latitude and longitude from DetailForm to RestaurantMap, we will use
Intent extras once again. So, define some public static String data members to use
as Intent extra keys in RestaurantMap:
public static final String EXTRA_LATITUDE="apt.tutorial.EXTRA_LATITUDE";
public static final String EXTRA_LONGITUDE="apt.tutorial.EXTRA_LONGITUDE";
public static final String EXTRA_NAME="apt.tutorial.EXTRA_NAME";
Then...we have a problem.
In DetailForm, the only point where we have the Cursor for loading our data is in
the load() method. By the time we get to onOptionsItemSelected() to launch the
RestaurantMap, we no longer have that Cursor. We could parse it out of the
TextView displaying those coordinates, but that would be a hassle.
So, in DetailForm, add a pair of data members to cache the latitude and longitude:
Double latitude=0.0d;
double
longitude=0.0d;
Then, populate those in the load() method of DetailForm:
private void load() {
Cursor c=helper.getById(restaurantId);
c.moveToFirst();
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
notes.setText(helper.getNotes(c));
feed.setText(helper.getFeed(c));
if (helper.getType(c).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(c).equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
latitude=helper.getLatitude(c);
longitude=helper.getLongitude(c);
222
Putting Lunch on the Map
location.setText(String.valueOf(latitude)
+ ","
+String.valueOf(longitude));
c.close();
}
Now, we can modify onOptionsItemSelected() to put the latitude and longitude in
as Intent extras, along with the name of the restaurant for good measure:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.feed) {
if (isNetworkAvailable()) {
Intent i=new Intent(this, FeedActivity.class);
i.putExtra(FeedActivity.FEED_URL,
startActivity(i);
feed.getText().toString());
}
else {
Toast
.makeText(this, "Sorry, the Internet is not available",
Toast. LENGTH_LONG)
.show();
}
return(true);
}
else if (item.getItemId()==R.id.location) {
locMgr.requestLocationUpdates(LocationManager.GPS_PROVIDER,
0, 0, onLocationChange);
return(true);
}
else if (item.getItemId()==R.id.map) {
Intent i=new Intent(this, RestaurantMap.class);
i.putExtra(RestaurantMap.EXTRA_LATITUDE, latitude);
i.putExtra(RestaurantMap.EXTRA_LONGITUDE, longitude);
i.put Ext ra(RestaurantMap.EXTRA_NAME, name.getText().toSt ring());
startActivity(i);
return(true);
}
return(super.onOptionsItemSelected(item));
}
223
Putting Lunch on the Map
The complete DetailForm class, with all the modifications for this tutorial, should
resemble:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
android.app.Activity;
android.content.Intent;
android.database.Cursor;
android.location.Location;
android.location.LocationListener;
android.location.LocationManager;
android.net.ConnectivityManager;
android.net.Networklnfo;
android.os.Bundle;
android.view.Menu;
android.view.Menulnflater;
android.view.Menultem;
android.view.View;
android.widget.EditText;
android.widget.RadioGroup;
android.widget.TextView;
android.widget.Toast;
public class DetailForm extends Activity {
EditText name=null; EditText address=null;
EditText notes=null; EditText feed=null;
RadioGroup types=null; RestaurantHelper
helper=null; String restaurantId=null;
TextView location=null; LocationManager
locMgr=null; double latitude=0.0d; double
longitude=0.0d;
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.detail_form);
locMgr=(LocationManager)getSystemService(LOCATION_SERVICE);
helper=new RestaurantHelper(this);
name=(EditText)findViewById(R.id.name);
address=(EditText)findViewById(R.id.addr);
notes=(EditText)findViewById(R.id.notes);
types=(RadioGroup)findViewById(R.id.types);
feed=(EditText)findViewById(R.id.feed);
location=(TextView)findViewById(R.id.location);
restaurantId=getIntent().getStringExtra(LunchList.ID_EXTRA);
224
Putting Lunch on the Map
if (restaurantId!=null) {
load();
}
}
@Override
public void onPause() {
save();
super.onPause();
}
@Override
public void onDestroy() {
helper.close();
locMgr.removeUpdates(onLocationChange);
super.onDestroy();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
new MenuInflater(this).inflate(R.menu.details_option, menu);
return(super.onCreateOptionsMenu(menu));
}
^Override
public boolean onPrepareOptionsMenu(Menu menu) { if
(restaurantId==null) {
menu.findItem(R.id.location).setEnabled(false);
menu.findItem(R.id.map).setEnabled(false);
}
return(super.onPrepareOptionsMenu(menu));
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId()==R.id.feed) {
if (isNetworkAvailable()) {
Intent i=new Intent(this, FeedActivity.class);
i.putExtra(FeedActivity.FEED_URL,feed.getText().toString());
startActivity(i);
}
else {
Toast
.makeText(this, "Sorry, the Internet is not available",
Toast.LENGTH_LONG)
.show();
}
return(true);
225
Putting Lunch on the Map
}
else if (item.getItemId()==R.id.location) {
locMgr.requestLocationUpdates(LocationManager.GPS_PROVIDER,
0, 0, onLocationChange);
return(true);
}
else if (item.getItemId()==R.id.map) {
Intent i=new Intent(this, RestaurantMap.class);
i.putExtra(RestaurantMap.EXTRA_LATITUDE, latitude);
i.putExtra(RestaurantMap.EXTRA_LONGITUDE, longitude);
i.putExtra(RestaurantMap.EXTRA_NAME, name.getText().toString());
startActivity(i);
return(true);
}
return(super.onOptionsItemSelected(item));
}
private boolean isNetworkAvailable() {
ConnectivityManager
cm=(ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);
Networklnfo info=cm.getActiveNetworkInfo();
return(info!=null);
}
private void load() {
Cursor c=helper.getById(restaurantId);
c.moveToFirst();
name.setText(helper.getName(c));
address.setText(helper.getAddress(c));
notes.setText(helper.getNotes(c));
feed.setText(helper.getFeed(c));
if (helper.getType(c).equals("sit_down")) {
types.check(R.id.sit_down);
}
else if (helper.getType(c).equals("take_out")) {
types.check(R.id.take_out);
}
else {
types.check(R.id.delivery);
}
latitude=helper.getLatitude(c);
longitude=helper.getLongitude(c);
location.setText(String.valueOf(latitude)
226
Putting Lunch on the Map
+ "," + String.valueOf(longitude));
c.close();
}
private void save() {
String type=null;
switch (types.getCheckedRadioButtonId()) {
case R.id.sit_down:
type="sit_down";
break;
case
R.id.take_out:
type="take_out";
brea
k;
defaul
t:
type="delivery";
break;
}
if (restaurantId==null) {
helper.insert(name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toString());
}
else {
helper.update(restaurantId, name.getText().toString(),
address.getText().toString(), type,
notes.getText().toString(),
feed.getText().toSring());
}
finish();
}
LocationListener onLocationChange=new LocationListener() {
public void onLocationChanged(Location fix) {
helper.updateLocation(restaurantId, fix.getLatitude(),
fix.getLongitude());
location.setText(String.valueOf(fix.getLatitude())
+", "
+String.valueOf(fix.getLongitude()));
locMgr.removeUpdates(onLocationChange);
Toast
.makeText(DetailForm.this, "Location saved",
Toast.LENGTH_LONG)
.show();
}
public void onProviderDisabled(String provider) { // required for
interface, not used
}
227
Putting Lunch on the Map
public void onProviderEnabled(String provider) { //
required for interface, not used
}
public void onStatusChanged(String provider, int status,
Bundle extras) { //
required for interface, not used
}
};
}
In RestaurantMap, we can retrieve these extras by adding a couple of lines to
onCreate():
double lat=getIntent().getDoubleExtra(EXTRA_LATITUDE, 0);
double lon=getIntent().getDoubleExtra(EXTRA_LONGITUDE, 0);
It might be nice to center the map on this location, so we know the marker will be
visible. And, we can set the zoom level of the map to a reasonable level, so we are
not viewing a map of the world or something at the outset. To do these things, we
will need to access our MapView and its accompanying MapController. And, wewill
need to convert our latitude and longitude into a GeoPoint, which stores the
latitude and longitude in microdegrees (10 times the number of degrees), so
Google Maps can do all its necessary calculations using fixed-point math.
To do all that, add a MapView data member named map:
private MapView map=null;
Then, add these few lines to onCreate(), after the lines you added above to retrieve
the latitude and longitude:
map=(MapView)findViewById(R.id.map);
map.getController().setZoom(17);
GeoPoint status=new GeoPoint((int)(lat*1000000.0),
(int)(lon*1000000.0));
map.getController().setCenter(status);
map.setBuiltInZoomControls(true);
228
Putting Lunch on the Map
Of course, we still do not have our overlay.
While there is an Overlay class as part of the Google Maps add-on for Android,
ItemizedOverlay will be far simpler for our use case - Overlay is for drawing lines
and shaded areas, while ItemizedOverlay is for placing markers on discrete points.
Here is a minimalist ItemizedOverlay subclass, named RestaurantOverlay, which we
can use as an inner class of RestaurantMap:
private class RestaurantOverlay extends ItemizedOverlay<OverlayItem> {
private Overlayltem item=null;
public RestaurantOverlay(Drawable marker, GeoPoint point,
String name) {
super(marker);
boundCenterBottom(marker);
item=new OverlayItem(point, name, name);
populate();
}
@Override
protected Overlayltem createItem(int i) {
return(item);
}
@Override
public int size()
{ return(1);
}
}
In the constructor, we are receiving as parameters our GeoPoint, plus the
restaurant's name, and a Drawable image to use for the actual map marker. The
constructor calls boundCenterBottom() - if the marker's "point" is centered on the
bottom of the image, boundCenterBottom() will set up our drop shadow for us. It also
creates an OverlayItem for our restaurant, passing it the GeoPoint, plus the name as
both the name of the itemand the item's "snippet".
At this point, RestaurantOverlay calls populate() , which triggers Android to call
size() on the overlay (which returns 1, the sum total of points we are
229
Putting Lunch on the Map
drawing), and then getItem() for each item (which returns the OverlayItem created
in the constructor).
To use this, we need to add a few more lines to the bottom of onCreate() of
RestaurantMap:
Drawable marker=getResources().getDrawable(R.drawable.marker);
marker.setBounds(0, 0, marker.getIntrinsicWidth(),
marker.getIntrinsicHeight());
map
.getOverlays()
.add(new RestaurantOverlay(marker, status,
getIntent().getStringExtra(EXTRA_NAME)));
Here, we load a Drawable resource (you will need a corresponding file in
res/drawable/ culled from somewhere) and tell the map to add our
RestaurantOverlay to its roster of overlays.
You will need to add a handful of imports:
•
android.graphics.drawable.Drawable
•
com.google.android.maps.GeoPoint
•
com.google.android.maps.ItemizedOverlay
•
com.google.android.maps.MapView
•
com.google.android.maps.Overlayltem
Step #4: Handle Marker Taps
The last piece of the puzzle is to respond when the user taps on the restaurant...
just for fun. To do this, add an onTap() method to RestaurantOverlay:
@Override
protected boolean onTap(int i) {
Toast.makeText(RestaurantMap .this,
item.getSnippet(),
Toast.LENGTH_SHORT).show();
230
Putting Lunch on the Map
return(true);
}
We are passed in the index of the marker the user tapped, which in this case will
always be o since there is but one marker. Here, we just display a Toast,
containing the name of the restaurant, stashed in the OverlayItem's "snippet". You
will need to add an import for android.widget.Toast, though.
The complete RestaurantMap class should look a wee bit like:
package apt.tutorial;
import
import
import
import
import
import
import
import
import
android.graphics.drawable.Drawable;
android.os.Bundle;
android.widget.Toast;
com.google.android.maps.GeoPoint;
com.google.android.maps.ItemizedOverlay;
com.google.android.maps.MapActivity;
com.google.android.maps.MapController;
com.google.android.maps.MapView;
com.google.android.maps.Overlayltem;
public class RestaurantMap extends MapActivity {
public static final String EXTRA_LATITUDE="apt.tutorial.EXTRA_LATITUDE";
public static final String EXTRA_LONGITUDE="apt.tutorial.EXTRA_LONGITUDE";
public static final String EXTRA_NAME="apt.tutorial.EXTRA_NAME";
private MapView map=null;
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.map);
double lat=getIntent().getDoubleExtra(EXTRA_LATITUDE, 0);
double lon=getIntent().getDoubleExtra(EXTRA_LONGITUDE, 0);
map=(MapView)findViewById(R.id.map);
map.getController().setZoom(17);
GeoPoint status=new GeoPoint((int)(lat*1000000.0),
(int)(lon*1000000.0));
map.getController().setCenter(status);
map.setBuiltInZoomControls(true);
Drawable marker=getResources().getDrawable(R.drawable.marker);
marker.setBounds(0, 0, marker.getIntrinsicWidth(),
marker.getIntrinsicHeight());
231
Putting Lunch on the Map
map
.getOverlays()
.add(new RestaurantOverlay(marker, status,
getIntent().getStringExtra(EXTRA_NAME)));
}
@Override
protected boolean isRouteDisplayed() {
return(false);
}
private class RestaurantOverlay extends ItemizedOverlay<OverlayItem> {
private Overlayltem item=null;
public RestaurantOverlay(Drawable marker, GeoPoint point,
String name) {
super(marker);
boundCenterBottom(marker);
item=new OverlayItem(point, name, name);
populate();
}
@Override
protected Overlayltem createItem(int i) {
return(item);
}
@Override
protected boolean onTap(int i) {
Toast.makeText(RestaurantMap.this,
item.getSnippet(),
Toast.LENGTH_SHORT).show();
return(true);
}
@Override
public int size() {
return(1);
}
}
}
If you compile and run this project, in the detail form for a restaurant, you will see
the new options menu item:
232
Putting Lunch on the Map
Figure 36. The detail form, with the new Map options menu item
Tapping it will bring up the map on the stated location:
233
Putting Lunch on the Map
Figure 37. The "restaurant" location shown on the map
And tapping on the marker displays the Toast:
234
Putting Lunch on the Map
Figure 38. The "restaurant" name in a Toast
If all you see is your marker floating atop a grey screen with gridlines, here are the
possible problems:
•
You forgotyour API key in the res/layout/map.xml file.
•
Your device or emulator does not have Internet access (e.g., the emulator
shows zero bars of signal strength). In the case of the emulator, if your
development machine has Internet access, try simply restarting the
emulator. If that does not help, there may be firewall issues at your
location.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Give the user some means of opening the actual Google Maps application
on the location, instead of our own MapActivity. For example, that way
they can get driving directions to the restaurant.
•
Experiment with different zoom levels as the starting point.
235
Putting Lunch on the Map
Add an options menu item on the LunchList activity to launch
RestaurantMap with no extras. When RestaurantMap detects the lack of
extras in onCreate(), it can use RestaurantHelper to load all the restaurants
that have a latitude and longitude and display all of them on the map.
Further Reading
Integration with Google Maps is covered in the "Mapping with MapView and
MapActivity" chapter of The Busy Coder's Guide to Android Development.
Also, bear in mind that the documentation for Android's mapping code is not
found in the Android developerguide directly, but rather at thesite for the Google
add-on for Android.
236
TUTORIAL 19
Is It Lunchtime Yet?
Now that we are keeping tabs on possible places to go to lunch, we still have only
addressed the "space" portion of "the space-time continuum". There is a matter of
time, especially lunchtime, to consider. If we help the user choose where to go to
lunch, we can also help remind the user when it is time to go to lunch.
Of course, some users would just use whatever "alarm clock" application exists on
their device. Such users are boring, and we will not consider them further.
Hence, in this tutorial, wewill add some preferences related to alerting the user
when lunch is, then use AlarmManager - which, despite its name, has nothing to do
with alarm clocks - to let us know when that time arrives, so we can in turn let the
user know.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 18-Map edition of LunchList
to use as a starting point.
237
Is It Lunchtime Yet?
Step #1: Create a TimePreference
We want the user to specifya time when we should remind them to go have lunch.
We could have a whole activity dedicated to this. However, this feels like an
application setting, so it would be nice if we could collect our alarm information
via SharedPreferences and our existing EditPreferences activity.
However, there is no TimePreference designed for collecting a time. Fortunately,
building one is not too difficult.
Add a new class, TimePreference.java, to the LunchList project, in the apt.tutorial
package, extending DialogPreference, that looks like this:
package apt.tutorial;
import
import
import
import
import
import
android.content.Context;
android.content.res.TypedArray;
android.preference.DialogPreference;
android.util.AttributeSet;
android.view.View;
android.widget.TimePicker;
public class TimePreference extends DialogPreference {
private int lastHour=0;
private int lastMinute=0;
private TimePicker picker=null;
public static int getHour(String time) {
String[] pieces=time.split(":");
return(Integer.parseInt(pieces[0]));
}
public static int getMinute(String time) {
String[] pieces=time.split(":");
return(Integer.parseInt(pieces[1]));
}
public TimePreference(Context ctxt) {
this(ctxt, null);
}
{
public TimePreference(Context ctxt, AttributeSet attrs)
this(ctxt, attrs, 0);
}
public TimePreference(Context ctxt, AttributeSet attrs,
int defStyle) {
238
Is It Lunchtime Yet?
super(ctxt, attrs, defStyle);
setPositiveButtonText("Set");
setNegativeButtonText("Cancel");
}
@Override
protected View onCreateDialogView() {
picker=new TimePicker(getContext());
return(picker);
}
@Override
protected void onBindDialogView(View v) {
super.onBindDialogView(v);
picker.setCurrentHour(lastHour);
picker.setCurrentMinute(lastMinute);
}
@Override
protected void onDialogClosed(boolean positiveResult) {
super.onDialogClosed(positiveResult);
if (positiveResult) {
lastHour=picker.getCurrentHour();
lastMinute=picker.getCurrentMinute();
String time=String.valueOf(lastHour)+":"+String.valueOf(lastMinute);
if (callChangeListener(time)) {
persistString(time);
}
}
}
@Override
protected Object onGetDefaultValue(TypedArray a, int index) {
return(a.getString(index));
}
@Override
protected void onSetInitialValue(boolean restoreValue, Object defaultValue) {
String time=null;
if (restoreValue) {
if (defaultValue==null) {
time=getPersistedString("00:00");
}
else {
time=getPersistedString(defaultValue.toString());
}
}
239
Is It Lunchtime Yet?
else {
time=defaultValue.toString();
}
lastHour=getHour(time);
lastMinute=getMinute(time);
}
}
There is a fair amount of code here. Let's review what the various methods are for:
•
getHour()
and getMinute() are static helper methods, to extract the hour
and minute, as integers, from a string encoded in HH:MM format. We have
to store our time collected by TimePreference as a single piece of data in
the SharedPreferences, so storing it as an HH:MM formatted string seems like
a reasonable choice.
•
We have all three flavors of a Preference constructor, all routing to the
third one. Mostly, that is for the superclass' use. However, we do indicate
what captions should be for the positive and negative buttons at the
bottom of the dialog.
•
onCreateDialogView()
•
onBindDialogView()
will be called as part of the dialog box being
displayed. We need to return a View that represents the content of the
dialog. We could inflate a layout here, if we wanted. However, for
simplicity, we are simply using a TimePicker widget constructed directly in
Java.
will be called after onCreateDialogView(), and our job is
to fill in whatever preference data should go into that dialog. Some other
methods described later in this list will have been called first, populating a
lastHour and lastMinute pair of data members with the hour and minute
from the SharedPreferences. We just turn around and pop those into the
TimePicker.
•
will be called when the user clicks either the positive or
negative button, or clicks the BACK button (same as clicking the negative
button). If they clicked the positive button, we assemble a new HH:MM string
from the values in the TimePicker, then tell DialogPreference to persist that
value to the SharedPreferences.
onDialogClosed()
240
Is It Lunchtime Yet?
will be called when Android needs us to convert an
attribute into an object of the appropriate data type.
For example, an integer preference would need to convert the
android:defaultValue String to an Integer. In our case, our preference is
being stored as a String, so we can extract the String from the TypedArray
that represents all of the attributes on this preference in the preference
XML resource.
onGetDefaultValue()
android:defaultValue
Finally, onSetInitialValue() will be called before onBindDialogView(),
where we are told the actual preference value to start with. That could be
an actual saved preference value from before, or the android:defaultValue
value, or nothing at all (in which case, we start with "00:00"). Wherever
the string comes from, we parse it into the lastHour and lastMinute integer
data members for use by onBindDialogView() .
Step #2: Collect Alarm Preferences
Now that we have a TimePreference, we can use it to find out when the user wants
to be alerted for lunchtime. However, users might not want to be alerted at all, so
we should really add two preferences: a CheckBoxPreference to enable lunchtime
alerts, plus the TimePreference to find out when that alert should show.
So, add a couple of new elements to res/xml/preferences.xml in your LunchList
project:
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android">
<ListPreference
android:key="sort_order"
android:title="Sort Order"
android:summary="Choose the order the list uses"
android:entries="@array/sort_names"
android:entryValues="@array/sort_clauses"
android:dialogTitle="Choose a sort order" />
<CheckBoxPreference android:key="alarm"
android:title="Sound a Lunch Alarm"
android:summary="Check if you want to know when it is time for lunch" />
<apt.tutorial.TimePreference
android:key="alarm_time"
241
Is It Lunchtime Yet?
android:title="Lunch Alarm Time"
android:defaultValue="12:00"
android:summary="Set your desired time for the lunch alarm"
android:dependency="alarm" />
</PreferenceScreen>
The CheckBoxPreference, keyed as alarm, is not particularly unusual. Our
TimePreference, keyed as alarm_time, has a few things worth mentioning:
•
Since our custom class is not a standard preference class, the element
name is the fully-qualified class name ( apt.tutorial.TimePreference ).
•
It has android:defaultValue set to "12:00" (the ANSI standard time for
lunch), in case the user toggles on the CheckBoxPreference but fails to
update the time itself.
•
By having android:dependency="alarm", the TimePreference will be disabled
if the CheckBoxPreference is unchecked. Since that preference starts off
unchecked, the TimePreference starts off disabled.
To collect these preferences from the user, all we have to do is adjust this resource.
EditPreferences will automatically start collecting the new information. However,
for other reasons, we will be making some modifications to EditPreferences, later
in this tutorial.
Step #3: Set Up a Boot-Time Receiver
We are going to use AlarmManager for returning control to us every day when the
user's specified lunchtime arrives. However, AlarmManager has one serious
limitation when compared with cron or Windows Scheduled Tasks: on a reboot,
the alarm schedule is wiped clean. Hence, many applications that intend to use
AlarmManager will also need to get control at boot time, simply to set up the alarm
again. So, we will add that logic to LunchList.
Create a new Java class, OnBootReceiver.java, in the apt.tutorial package,
inheriting from BroadcastReceiver, that looks like this:
242
Is It Lunchtime Yet?
package apt.tutorial;
import android.content.BroadcastReceiver;
mport android.content.Context;
import android.content.Intent;
public class OnBootReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context ctxt, Intent intent) {
// do something
}
}
The "real" work for a BroadcastReceiver is in the onReceive() method. In our case,
that is a placeholder for the moment, to be addressed in the next step.
We also need to add a <receiver> element to the manifest, identifying that
OnBootReceiver should get control when the system broadcasts the BOOT_COMPLETED
event. However, to be able to register such a receiver, we need to hold the
RECEIVE_BOOT_COMPLETED permission, so users know that we are trying to get control at
boot time.
So, add that permission and the corresponding <receiver> element to
AndroidManifest.xml, resulting in a file that should resemble:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial"
android:versionCode="1"
android:versionName="1.0">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
application android:label="@string/app_name">
<uses-library android:name="com.google.android.maps" />
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".DetailForm">
</activity>
<activity android:name=".EditPreferences">
</activity>
_____ <activity android:name=".FeedActivity">
243
Is It Lunchtime Yet?
</activity>
<activity android:name=".RestaurantMap">
</activity>
<service android:name=".FeedService">
</service>
<receiver android:name=".OnBootReceiver" android:enabled="false">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/> </intent-filter>
</receiver>
</application>
</manifest>
If you look closely, you will notice something a bit unusual about that <receiver>
element: we have android:enabled="false", meaning that the BroadcastReceiver is
disabled by default. There is a reason for that, which we'll see in the next step.
Step #4: Manage Preference Changes
When the user toggles on the alarm CheckBoxPreference, we want to set up
AlarmManager to wake us up daily at the requested time.
If the user changes the alarm time (e.g., from 12:00 to 12:30), we want to cancel the
existing alarm and set up a new one with AlarmManager.
If the user toggles off the alarm CheckBoxPreference, we want to cancel the existing
alarm.
And, on a reboot, if the alarm was requested, we want to set up AlarmManager.
That sounds like a fair amount of work, but it is not really all that bad. There are
two major operations (set and cancel alarms) and two major triggers (preference
changes and a reboot).
First, letus set up the code to setand cancel thealarms. Sincewe need this both
from whatever detects the preference changes and OnBootReceiver, we should have
these methods be reachable from both places. The easiestway
244
Is It Lunchtime Yet?
to do that is to make them static methods, and lacking a better spot, we may as
well tuck those static methods on OnBootReceiver.
So, add these methods to OnBootReceiver:
public static void setAlarm(Context ctxt) {
AlarmManager mgr=(AlarmManager)ctxt.getSystemService(Context.ALARM_SERVICE);
Calendar cal=Calendar.getInstance();
SharedPreferences prefs=PreferenceManager.getDefaultSharedPreferences(ctxt);
String time=prefs.getString("alarm_time", "12:00");
cal.set(Calendar.HOUR_OF_DAY, TimePreference.getHour(time));
cal.set(Calendar.MINUTE, TimePreference.getMinute(time));
cal.set(Calendar.SECOND, 0); cal.set(Calendar.MILLISECOND, 0);
if (cal.getTimeInMillis()<System.currentTimeMillis()) {
cal.add(Calendar.DAY_OF_YEAR, 1);
}
mgr.setRepeating(AlarmManager.RTC_WAKEUP
cal getTimeInMillis(),
AlarmManager.INTERVAL_DAY,
getPendingIntent(ctxt));
}
public static void cancelAlarm(Context ctxt) {
AlarmManager mgr=(AlarmManager)ctxt.getSystemService(Context.ALARM_SERVICE);
mgr.cancel(getPendingIntent(ctxt));
}
private static Pendinglntent getPendingIntent(Context ctxt) { Intent
i=new Intent(ctxt, OnAlarmReceiver.class);
return(PendingIntent.getBroadcast(ctxt, 0, i, 0));
}
Also, update onReceive() of OnBootReceiver to call our setAlarm() method:
@Override
public void onReceive(Context ctxt, Intent intent) {
setAlarm(ctxt);
}
Now, let's take a look at what we have added.
setAlarm()
will be called from onReceive(). Here, we get access to AlarmManager via
plus access our SharedPreferences. We
getSystemService(),
245
Is It Lunchtime Yet?
find the alarm_time preference and create a Calendar object that has the requested
hour and minute. However, we may need to adjust the day - if it is before the
alarm time today, we want the next alarm to be today's; if it is after today's alarm
should have gone off, we want the next alarm to be tomorrow's.
Then, we call setRepeating() on AlarmManager to actually schedule the alarm. We
specify an RTC_WAKEUP alarm, meaning that we will get control at the time specified by
the Calendar object, even if the device is asleep at the time. We specify INTERVAL_DAY,
so the alarm will go off every 24 hours after the first one. And, we call our
getPendingIntent() method to say what we are going to do when the alarm goes off
- here, we are going to send a broadcast to another BroadcastReceiver,
OnAlarmReceiver, that we will set up in the next step.
simply creates an equivalent Pendingintent and calls cancel() on
AlarmManager. This can be called blindly, since if the alarm is not scheduled,
AlarmManager will simply ignore the cancel request.
cancelAlarm()
You will need to add the following imports:
•
android.app.AlarmManager
•
android.app.Pendinglntent
•
android.content.SharedPreferences
•
android.preference.PreferenceManager
•
java.util.Calendar
The complete OnBootReceiver class, with these changes, should look a bit
like:
package apt.tutorial;
import
import
import
import
import
import
import
import
android.app.AlarmManager;
android.app.Pendingintent;
android.content.BroadcastReceiver;
android.content.Context;
android.content.Intent;
android.content.SharedPreferences;
android.preference.PreferenceManager;
java.util.Calendar;
246
Is It Lunchtime Yet?
public class OnBootReceiver extends BroadcastReceiver {
public static void setAlarm(Context ctxt) {
AlarmManager mgr=(AlarmManager)ctxt.getSystemService(Context.ALARM_SERVICE);
Calendar cal=Calendar.getInstance();
SharedPreferences prefs=PreferenceManager.getDefaultSharedPreferences(ctxt);
String time=prefs.getString("alarm_time", "12:00");
cal.set(Calendar.HOUR_OF_DAY, TimePreference.getHour(time));
cal.set(Calendar.MINUTE, TimePreference.getMinute(time));
cal.set(Calendar.SECOND, 0); cal.set(Calendar.MILLISECOND, 0);
if (cal.getTimeInMillis()<System.currentTimeMillis()) {
cal.add(Calendar.DAY_OF_YEAR, 1);
}
mgr.setRepeating(AlarmManager.RTC_WAKEUP
cal getTimeInMillis(),
AlarmManager.INTERVAL_DAY,
getPendingIntent(ctxt));
}
public static void cancelAlarm(Context ctxt) {
AlarmManager mgr=(AlarmManager)ctxt.getSystemService(Context.ALARM_SERVICE);
mgr.cancel(getPendingIntent(ctxt));
}
private static Pendingintent getPendingIntent(Context ctxt) {
Intent i=new Intent(ctxt, OnAlarmReceiver.class);
return(PendingIntent.getBroadcast(ctxt, 0, i, 0));
}
@Override
public void onReceive(Context ctxt, Intent intent) {
setAlarm(ctxt);
}
}
You will notice that we are blindly setting up the alarm via onReceive(). This
would seem to be a mistake - after all, if the user has not requested the alarm, we
should not be setting it up. Conversely, if you recall from the previous step that
OnBootReceiver is initially disabled, that too would seem to be a bug, since we will
never set up the alarm on a reboot. In truth, we will be toggling whether or not
OnBootReceiver is enabled based upon preference changes, so it will only get
control if it is needed. This means that users who elect to have alarms will have
them even after a reboot, but users who skip the alarms get a slightly faster reboot,
since our code will not be executed.
247
Is It Lunchtime Yet?
We also need to get control when the user changes their preferences. The standard
way to do this is to register an OnSharedPreferenceChangeListener, which will be
notified on SharedPreferences changes. Since the only place we are actually
changing the SharedPreferences is from the EditPreferences activity, we may as well
use OnSharedPreferenceChangeListener there.
Add the following code to EditPreferences:
@Override
public void onResume() {
super.onResume();
prefs=PreferenceManager.getDefaultSharedPreferences(this);
prefs.registerOnSharedPreferenceChangeListener(onChange);
}
@Override
public void onPause() {
prefs.unregisterOnSharedPreferenceChangeListener(onChange);
super.onPause();
}
SharedPreferences.OnSharedPreferenceChangeListener
onChange=
SharedPreferences.OnSharedPreferenceChangeListener() {
new
public void onSharedPreferenceChanged(SharedPreferences prefs,
String key) {
if ("alarm".equals(key)) {
boolean enabled=prefs.getBoolean(key, false); int
flag=(enabled ?
PackageManager.COMPONENT_ENABLED_STATE_ENABLED :
PackageManager.COMPONENT_ENABLED_STATE_DISABLED);
ComponentName component=new ComponentName(EditPreferences.this,
OnBootReceiver.class);
getPackageManager()
.setComponentEnabledSetting(component,
flag,
PackageManager.DONT_KILL_APP);
if (enabled) {
OnBootReceiver.setAlarm(EditPreferences.this);
}
else {
OnBootReceiver.cancelAlarm(EditPreferences.this);
}
}
else if ("alarm_time".equals(key)) {
OnBootReceiver.cancelAlarm(EditPreferences.this);
OnBootReceiver.setAlarm(EditPreferences .this);
}
248
Is It Lunchtime Yet?
}
};
ou will also need to add a SharedPreferences data member named prefs:
SharedPreferences prefs=null;
And, you will need to add some imports:
In
•
android.content.ComponentName
•
android.content.SharedPreferences
•
android.content.pm.PackageManager
•
android.preference.PreferenceManager
and
call
registeringour
OnSharedPreferenceChangeListener (named onChange). We unregister this in
onPause(). That way, while the user has the activity up and is interacting with it,
we will find out about changes in preferences.
onResume(),
we
get
at
the
SharedPreferences
registerOnSharedPreferenceChangeListener(),
Our
will
be
called
with
whenever the user changes any o f t h e preferences.
If they toggle the alarm preference, we find out whatthe current setting is. Then,
we call setComponentEnabledSetting() o n t h e PackageManager to enable or disable
OnBootReceiver. Since our alarm preference is set to be off by default, and our
<receiver> element said that OnBootReceiver was disabled by default, we should
remain in sync. Also, we call setAlarm() or cancelAlarm() depending on the state of
the alarm preference. If they change the alarm_time preference, we know that the
alarm preference must be on (otherwise, they cannot change alarm_time), so we
cancel the old alarm and schedule a new one for the new time.
OnSharedPreferenceChangeListener
onSharedPreferenceChanged()
The complete edition of EditPreferences, with these changes, should resemble:
package apt.tutorial;
import android.app.Activity;
import android.content.ComponentName;
249
Is It Lunchtime Yet?
import
import
import
import
import
android.content.SharedPreferences;
android.content.pm. PackageManager;
android.os.Bundle;
android.preference.PreferenceActivity;
android.preference.PreferenceManager;
public class EditPreferences extends PreferenceActivity {
SharedPreferences prefs=null;
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
addPreferencesFromResource(R.xml.preferences);
}
@Override
public void onResume() {
super.onResume();
prefs=PreferenceManager.getDefaultSharedPreferences(this);
prefs.registerOnSharedPreferenceChangeListener(onChange);
}
@Override
public void onPause() {
prefs.unregisterOnSharedPreferenceChangeListener(onChange);
super.onPause();
}
SharedPreferences.OnSharedPreferenceChangeListener onChange=
new SharedPreferences.OnSharedPreferenceChangeListener() {
public void onSharedPreferenceChanged(SharedPreferences prefs,
String key) {
if ("alarm".equals(key)) {
boolean enabled=prefs.getBoolean(key, false); int
flag=(enabled ?
PackageManager.COMPONENT_ENABLED_STATE_ENABLED :
PackageManager.COMPONENT_ENABLED_STATE_DISABLED);
ComponentName component=new ComponentName(EditPreferences.this,
OnBootReceiver.class);
getPackageManager()
.setComponentEnabledSetting(component,
flag,
PackageManager.DONT_KILL_APP);
if (enabled) {
OnBootReceiver.setAlarm(EditPreferences. this);
}
else {
OnBootReceiver.cancelAlarm(EditPreferences.this);
}
250
Is It Lunchtime Yet?
}
else if ("alarm_time".equals(key)) {
OnBootReceiver.cancelAlarm(EditPreferences.this);
OnBootReceiver.setAlarm(EditPreferences.this);
}
}
};
}
What is still missing is OnAlarmReceiver, which we will implement in the next step.
Step #5: Display the Alarm
Given all the work done in the previous step, our Pendingintent scheduled with
AlarmManager should be invoked at the specified time each day, if the user has
enabled alarms.
Now, we just need to do something at that time.
The code above has the Pendingintent send a broadcast to trigger an
OnAlarmReceiver class. That will not be able to directly display anything to the user,
since a BroadcastReceiver has no direct access to the UI. However, it can start an
activity. So, let's create an AlarmActivity that will be what we display to the user.
First, we need a layout, so create a res/layout/alarm.xml file that contains
something like this:
<?xml version="1.0" encoding="utf-8"?>
<TextView
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="It's time for lunch!"
android:textSize="30sp"
android:textStyle="bold"
/>
The AlarmActivity itself - another Activity subclass in the apt.tutorial package can be very trivial:
251
Is It Lunchtime Yet?
package apt.tutorial;
import android.app.Activity;
import android.os.Bundle;
public class AlarmActivity extends Activity {
@Override
public void onCreate(Bundle savedlnstanceState) {
super.onCreate(savedlnstanceState);
setContentView(R.layout.alarm);
}
}
Also create an OnAlarmReceiver subclass of BroadcastReceiver in the apt.tutorial
package, and have it call startActivity() to bring up AlarmActivity:
package apt.tutorial;
import android.content.BroadcastReceiver;
import android.content.Context; import
android.content.Intent;
public class OnAlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context ctxt, Intent intent) {
Intent i=new Intent(ctxt, AlarmActivity.class);
i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
ctxt.startActivity(i);
}
}
We need to add FLAG_ACTIVITY_NEW_TASK to the Intent, because if we do not, our
startActivity() call will fail with an error telling us to add FLAG_ACTIVITY_NEW_TASK.
Calling startActivity() from someplace other than an activity typically requires
this flag, though sometimes it is automatically added for you.
Finally, we need to add both of these to the manifest, via an <activity> and
<receiver> element, respectively:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="apt.tutorial"
android:versionCode="1"
252
Is It Lunchtime Yet?
android:versionName="1.0"> <uses-permission
android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
<supports-screens
android:xlargeScreens="true
"
android:largeScreens="true"
android:normalScreens="true
"
android:smallScreens="false
"
/>
<application android:label="@string/app_name">
<uses-library android:name="com.google.android.maps" />
<activity android:name=".LunchList"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intentfilter> </activity>
<activity android:name=".DetailForm">
</activity>
<activity android:name=".EditPreferences">
</activity>
<activity android:name=".FeedActivity">
</activity>
<activity android:name=".RestaurantMap">
</activity>
<activity android:name=".AlarmActivity">
</activity>
<service android:name=".FeedService">
</service>
<receiver android:name=".OnBootReceiver" android:enabled="false">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
</intentfilter> </receiver>
<receiver android:name=".OnAlarmReceiver">
</receiver>
</application>
</manifest>
The net effect is that when the AlarmManager alarm "sounds", OnAlarmReceiver will
get control and call startActivity() to open up AlarmActivity. We could have
bypassed OnAlarmReceiver, by using a getActivity() Pendingintent and have it open
AlarmActivity directly. The fact that we added OnAlarmReceiver suggests that maybe
- just maybe - we will be doing something more in this area in a future tutorial.
253
Is It Lunchtime Yet?
If you compile and install LunchList, the preference screen will have our two new
preferences:
Figure 39. The preferences, including a pair of new ones
oggling the alarm on will enable the time preference:
254
Is It Lunchtime Yet?
Figure 40. The preferences, all enabled this time
Tapping on the time preference will bringup our TimePreference dialog with the
TimePicker:
255
Is It Lunchtime Yet?
Figure 41. The TimePreference in action
When lunchtime rolls around, our AlarmActivity will appear out of nowhere:
256
Is It Lunchtime Yet?
Figure 42. The extremely bland AlarmActivity
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Rather than rolling our own alarm, use android.provider.AlarmClock to set
an alarm in the alarm clock app on the device.
•
Give the user some way to dismiss today's alarm in advance - for example,
they may have a lunch meeting scheduled before their normal time.
•
Allow the user to specify the time not via a TimePreference, but via an
EditTextPreference. Grumble as you work your way through parsing
algorithms for various ways the user might encode the time. Curse under
your breath when you realize that some users might try typing in "half
past noon". Realize why we went through the trouble to create
TimePreference in the first place.
•
Use the curiously-named Vibrator system service to shake the phone
when the alarm activity is displayed. You will need to hold
257
Is It Lunchtime Yet?
the VIBRATE permission, and you will need a device that has a vibration
motor (e.g., not the emulator and not some tablets like the Motorola
XOOM).
•
Make the alarm activity look more interesting.
Further Reading
You can learn more about the AlarmManager in the "Advanced Service Patterns"
chapter of The Busy Coder's Guide to Advanced Android Development. You can
read more about creating custom preferences in "Creating Custom Dialogs and
Preferences", also found in The Busy Coder's Guide to Advanced Android
Development.
258
TUTORIAL 20
More Subtle Lunch Alarms
Displaying the lunchtime alarm via a full-screen activity certainly works, and if the
user is looking at the screen, it will get their attention. However, it is also rather
disruptive if they happen to be using the phone right that instant. For example, if
they are typing a text message while driving, your alarm activity popping up out of
nowhere might distract them enough to cause an accident.
So, in the interest of public safety, we should give the user an option to have a
more subtle way to remind them to have lunch.
The best solution for this sort of a notification is a Notification, strangely enough,
so this tutorial will have us tie into NotificationManager when the user asks for that
style of lunch alarm.
Step-By-Step Instructions
First, you need to have completed the previous tutorial. If you are beginning the
tutorials here, or if you wish to not use your existing work, you can download a ZIP
file with all of the tutorial results, and you can copy the 19-Alarm edition of
LunchList to use as a starting point.
259
More Subtle Lunch Alarms
Step #1: Collect Alarm Style Preference
Since we need to give the users a choice between displaying AlarmActivity or a
Notification, and since we are collecting other alarm data via SharedPreferences,
it seems like a good idea to simply add another preference, this time for alarm
style.
Edit
to add a new CheckBoxPreference named
Make it depend upon the alarm preference (as does alarm_time),
and have it default to true, just to be safe:
res/xml/preferences.xml
use_notification.
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android">
<ListPreference
android:key="sort_order"
android:title="Sort Order"
android:summary="Choose the order the list uses"
android:entries="@array/sort_names"
android:entryValues="@array/sort_clauses"
android:dialogTitle="Choose a sort order" />
<CheckBoxPreference
android:key="alarm"
android:title="Sound a Lunch Alarm"
android:summary="Check if you want to know when it is time for lunch" />
<apt.tutorial.TimePreference
android:key="alarm_time"
android:title="Lunch Alarm Time"
android:defaultValue="12:00"
android:summary="Set your desired time for the lunch alarm"
android:dependency="alarm" />
<CheckBoxPreference
android:key="use_notification"
android:title="Use a Notification"
android:defaultValue="true"
android:summary="Check if you want a status bar icon at lunchtime, or uncheck for a
full-screen notice"
android:dependency="alarm" />
</PreferenceScreen>
There is nothing we need to do to the EditPreferences activity this time.
Step #2: Display the Alarm, Redux
The reason we set up the OnAlarmReceiver in the previous tutorial was to support
alerting the user by either a Notification or AlarmActivity.
260
More Subtle Lunch Alarms
can make the determination which approach to use, based on the
use_notification preference value. If we want the Notification, it can raise that
directly; otherwise, it can call startActivity() as before.
OnAlarmReceiver
Modify onReceive() of OnAlarmReceiver as follows:
@Override
public void onReceive(Context ctxt, Intent intent) {
SharedPreferences prefs=PreferenceManager.getDefaultSharedPreferences(ctxt);
boolean useNotification=prefs.getBoolean("use_notification",
true);
if (useNotification) {
NotificationManager mgr=
(NotificationManager)ctxt.getSystemService(Context.NOTIFICATION_SERVICE);
Notification note=new Notification(R.drawable.stat_notify_chat,
"It's time for lunch!", System.currentTimeMillis()); Pendingintent
i=PendingIntent.getActivity(ctxt, 0,
new Intent(ctxt, AlarmActivity.class),
0);
note.setLatestEventInfo(ctxt, "LunchList",
"It's time for lunch! Aren't you hungry?", i);
note.flags|=Notification.FLAG_AUTO_CANCEL;
mgr.notify(NOTIFY_ME_ID, note);
}
else {
Intent i=new Intent(ctxt, AlarmActivity.class);
i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
ctxt.startActivity(i);
}
}
You will also need a static data member for NOTIFY_ME_ID, a locally-unique integer to
identify this Notification from any others we might raise:
private static final int NOTIFY_ME_ID=1337;
You will need a new drawable resource, res/drawable/stat_notify_chat.png,
perhaps obtained from your Android SDK.
You will also need to add some imports:
261
More Subtle Lunch Alarms
•
android.app.Notification
•
android.app.NotificationManager
•
android.app.PendingIntent
•
android.content.SharedPreferences
•
android.preference.PreferenceManager
First,
we
get
use_notification
the SharedPreferences and look up use_notification. If
is false, we continue as before, calling startActivity().
If use_notification is true, however, we:
•
Obtain access to the NotificationManager via getSystemService()
•
Create a Notification object, indicating the icon, the "ticker text" (which
appears briefly in the status bar when the Notification is displayed), and
the timestamp associated with the event
•
Create a getActivity() Pendingintent for our AlarmActivity
•
Attaching that PendingIntent to the Notification via setLatestEventinfo(),
where we also supply a title and description to go in the tile for this
Notification in the status drawer
•
Add the FLAG_AUTO_CANCEL flag to the Notification, so tapping on its tile will
automatically dismiss the Notification
•
Call notify() on NotificationManager with our Notification, to have it be
displayed
The complete OnAlarmReceiver with these modifications should resemble:
package apt.tutorial;
import
import
import
import
import
import
import
import
android.app.Notification;
android.app.NotificationManager;
android.app.Pendingintent;
android.content.BroadcastReceiver;
android.content.Context;
android.content.Intent;
android.content.SharedPreferences;
android.preference.PreferenceManager;
public class OnAlarmReceiver extends BroadcastReceiver {
private static final int NOTIFY_ME_ID=1337;
262
More Subtle Lunch Alarms
@Override
public void onReceive(Context ctxt, Intent intent) {
SharedPreferences prefs=PreferenceManager.getDefaultSharedPreferences(ctxt);
boolean useNotification=prefs.getBoolean("use_notification",
true);
if (useNotification) {
NotificationManager mgr=
(NotificationManager)ctxt.getSystemService(Context.NOTIFICATION_SERVICE)
;
Notification note=new Notification(R.drawable.stat_notify_chat,
"It's time for lunch!",
System.currentTimeMillis());
Pendingintent i=PendingIntent.getActivity(ctxt, 0,
new Intent(ctxt, AlarmActivity.class),
0);
note.setLatestEventInfo(ctxt, "LunchList",
"It's time for lunch! Aren't you hungry?", i);
note.flags|=Notification.FLAG_AUTO_CANCEL;
mgr.notify(NOTIFY_ME_ID, note);
}
else {
Intent i=new Intent(ctxt, AlarmActivity.class);
i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
ctxt.startActivity(i);
}
}
}
If you compile and install the application, the preference screen will show the new
preference:
263
More Subtle Lunch Alarms
Figure 43. The new notification style preference
If you choose the Notification mode, when lunchtime arrives, your Notification
will appear in the status bar:
264
More Subtle Lunch Alarms
Figure 44. The notification, right as it is being added, showing the "ticker text"
Sliding down the drawer will show the entry for the Notification:
265
More Subtle Lunch Alarms
Figure 45. The notification drawer, showing the full notification
Tapping that entry will bring up AlarmActivity, as if OnAlarmReceiver had launched
it directly.
On an Android 3.0 device, though, the look will be somewhat different. The
Notification will appear initially as a bubble:
266
More Subtle Lunch Alarms
Figure 46. The notification on an Android 3.0 tablet
Figure 47. The notification drawer on an Android 3.0 tablet
The drawer now appears when tapping on the clock in the lower-right corner:
267
More Subtle Lunch Alarms
Tapping on either the bubble or the item in the drawer will trigger AlarmActivity.
Extra Credit
Here are some things you can try beyond those step-by-step instructions:
•
Experiment with the LED options with a Notification (e.g., ledARGB).
Note, though, that not all devices have LEDs, and those that do may not
support third-party applications playing with the LEDs. You will need to
add the FLAG_SHOW_LIGHTS flag as well for this to work.
•
Play with the sound field on Notification, pointing it to a file on external
storage containing an MP3 that you want to have played when the
Notification is displayed.
Further Reading
Notifications are covered in the "Alerting Users Via Notifications" chapter of The
Busy Coder's Guide to Android Development.
268
APPENDIX A
How To Get Started
Let us get you set up with the pieces and parts necessary to build an Android app.
If you would prefer not to install all of this software on your development machine,
you can download a Ubuntu VirtualBox image that contains everything described
below. Note that this image is 1.6GB and therefore may take some time to
download. This image will be updated periodically to reflect newer editions of the
Android SDK and development tools. Once downloaded, you can import the
contents of the ZIP archive into your VirtualBox environment - note that this will
create a second copy of the files, ones that VirtualBox will modify. When you go to
log in, the user account is android with a password of bugdroid. This account is set
up with sudo privileges, in case you need to make modifications to configuration
files or download OS patches (and if the term sudo does not ring a bell, just pay no
attention to this sentence).
NOTE: the instructions presented here are accurate as of the time of this writing.
However, the tools change rapidly, and so these instructions may be out of date by
the time you read this. Please refer to the Android Developers Web site for current
instructions, using this as a base guideline of what to expect.
269
How To Get Started
Java
When you write Android applications, you typically write them in Java source
code. That Java source code is then turned into the stuff that Android actually runs
(Dalvik bytecode in an APK file).
Hence, the first thingyou need to do is get set up with a Java development
environment and be ready to start writing Java classes.
Step #1: Install the JDK
You need to obtain and install the official Sun/Oracle Java SE SDK (JDK). You can
obtain this from the Oracle Java Web site for Windows and Linux, and presumably
from Apple for OS X. The plain JDK (sans any "bundles") should suffice. Follow the
instructions supplied by Oracle or Apple for installing i t o n your machine. At the
timeof this writing, Android supports Java 5 and Java 6, the latter being the nowcurrent edition.
Alternative Java Compilers
In principle, you are supposed to use the official Sun/Oracle Java SE SDK. In
practice, it appears that OpenJDK also works, at least on Ubuntu. However, the
further removed you get from the official Sun/Oracle implementation, the less
likely it is that it will work. For example, the GNU Compiler for Java (GCJ) may not
work with Android.
Step #2: Learn Java
This book, like most books and documentation on Android, assumes that you have
basic Java programming experience. If you lack this, you really should consider
spending a bit of time on Java fundamentals, before you dive into Android.
Otherwise, you may find the experience to be frustrating.
270
How To Get Started
If you are in need of a crash course in Java to get involved in Android
development, here are the concepts you need to succeed, presented in no
particular order:
•
Language fundamentals (flow control, etc.)
•
Classes and objects
•
Methods and data members
•
Public, private, and protected
•
Static and instance scope
•
Exceptions
•
Threads and concurrency control
•
Collections
•
Generics
•
File I/O
•
Reflection
•
Interfaces
Install the Android SDK
The Android SDK gives you all the tools you need to create and test Android
applications. It comes in two parts: the base tools, plus version-specific SDKs and
related add-ons.
Step #1: Install the Base Tools
The Android developer tools can be found on the Android Developers Web site.
Download the ZIP file appropriate for your platform and unZIP it in some likely
spot - there is no specific path that is required. Windows users also have the
option of running a self-installing EXE file.
271
How To Get Started
Step #2: Install the SDKs and Add-Ons
Inside the tools/ directory of your Android SDK installation from the previous
step, you will see an android batch file or shell script. If you run that, you will be
presented with the Android SDK and AVD Manager:
Figure 48. Android SDK and AVD Manager
At this point, while you havesome of the build tools, you lack the Java files
necessary to compile an Android application. You also lack a few additional build
tools, plus the files necessary to run an Android emulator.
To address this, click on the Available Packages option on the left. This brings up a
tree:
272
How To Get Started
Figure 49. Android SDK and AVD Manager Available Packages
Open the Android Repository branch of the tree. After a short pause, you will see a
screen similar to this:
Figure 50. Android SDK and AVD Manager Available Android Packages
You will want to check the following items:
•
"SDK Platform" for all Android SDK releases you want to test against
273
How To Get Started
•
"Documentation for Android SDK" for the latest Android SDK release
•
"Samples for SDK" for the latest Android SDK release, and perhaps for
older releases if you wish
Then, open the Third-Party Add-Ons branch of the tree. After a short pause, you
will see a screen similar to this:
Figure 51. Android SDK and AVD Manager Available Third-Party Add-Ons
Fold open the "Google Inc. add-ons" branch, which will display something like
this:
274
HowTo Get Started
Figure 52. Android SDK and AVD Manager Available Google Add-Ons
Most likely, you will want to check the "Google APIs by Google Inc." items that
match up with the SDK versions you selected in the Android Repository branch.
The "Google APIs" include support for Google Maps, both from your code and in
the Android emulator.
Figure 53. Android SDK and AVD Manger Installing Packages
275
HowTo Get Started
Review and accept the licenses, then click the Install button. At this point, this is a
fine time to go get lunch. Or, perhaps dinner. Unless you have a substantial
Internet connection, downloading all of this data and unpacking it will take a fair
bit of time.
When the download is complete, you can close up the SDK and AVD Manager if
youwish, thoughwe will use it to set up theemulator in a later step of this chapter.
Install the ADT for Eclipse
If you will not be using Eclipse for your Android development, you can skip to the
next section.
If you have not yet installed Eclipse, you will need to do that first. Eclipse can be
downloaded from the Eclipse Web site. The "Eclipse IDE for Java Developers"
package will work fine.
Next, you need to install the Android Developer Tools (ADT) plug-in. To do this,
go to Help | Install New Software... in the Eclipse main menu. Then, click the Add
button to add a new source of plug-ins. Give it some name (e.g., Android) and
supply the following URL: https://dl-ssl.google.com/android/eclipse/. That
should trigger Eclipse to download the roster of plug-ins available from that site:
276
HowTo Get Started
Figure 54. Eclipse ADT plug-in installation
Check the checkbox to the left of "Developer Tools" and click the Next button.
Follow the rest of the wizard to review the tools to be downloaded and their
respective license agreements. When the Finish button is enabled, click it, and
Eclipse will download and install the plug-ins. When done, Eclipse will ask to
restart - please let it.
Then, you need to teach ADT whereyour Android SDK installation is from the
preceding section.To do this, choose Window | Preferences from the Eclipse main
menu (or the equivalent Preferences option for OS X). Click on the Android entry
in the list on the left:
277
How To Get Started
Figure 55. Eclipse ADT configuration
Then, click the Browse... button to find the directory where you installed the SDK.
After choosing it, click Apply on the Preferences window, and you should see the
Android SDK versions you installed previously. Then, click OK, and the ADT will
be ready for use.
You may also wish to read the appendix with tips on working with the tutorials in
Eclipse.
Install Apache Ant
If you will be doing all of your development from Eclipse, you can skip to the next
section.
If you wish to develop using command-line build tools, you will need to install
Apache Ant. You may have this already from previous Java development work, as it
is fairly common in Java projects. However, you
278
How To Get Started
will need Ant version 1.8.1, so double-check your current copy (e.g., ant -version)
to ensure you are on the proper edition.
If you do not have Ant, you can obtain it from the Apache Ant Web sit . They have
full installation instructions in the Ant manual, but the basic steps are:
1.
Unpack the ZIP archive wherever it may make sense on your machine
2.
Add a JAVA_HOME environment variable, pointing to where your JDK is
installed, if you do not have one already
3.
Add an ANT_HOME environment variable, pointing to the directory where you
unpacked Ant in the first step above
4.
Add $JAVA_HOME/bin and $ANT_HOME/bin to your PATH
5.
Run ant -version to confirm that Ant is installed properly
Set Up the Emulator
The Android tools include an emulator, a piece of software that pretends to be an
Android device. This is very useful fordevelopment - not only does it mean you can
get started on Android without a device, but the emulator can help test device
configurations that you do not own.
The Android emulator can emulate one or several Android devices. Each
configuration you want is stored in an "Android Virtual Device", or AVD. The SDK
and AVD Manager, which you used to download the SDK components earlier in
this chapter, is where you create theseAVDs.
If you do not have the SDK andAVD Manager running, you can run it via the
android command from your SDK's tools/ directory, or via Window | SDK
andAVD Manager from Eclipse. It starts up on a screen listing the AVDs you have
available - initially, the list will be empty:
279
How To Get Started
Figure 56. Android SDK and AVD Manager
Click the New... button to create a new AVD file. This brings up a dialog where
youcan configure what thisAVD should look and work like:
Figure 57. Adding a New AVD
280
How To Get Started
You need to provide the following:
•
A name for the AVD. Since the name goes into files on your development
machine, you will be limited by filename conventions for your operating
system (e.g., no backslashes on Windows).
•
The Android version you want the emulator to run (a.k.a., the "target").
Choose one of the SDKs you installed via the drop-down list. Note that in
addition to "pure" Android environments, you will have options based on
the third-party add-ons you selected. For example, you probably have
some options for setting up AVDs containing the Google APIs, and you
will need such an AVD for testing an application that uses Google Maps.
•
Details about the SD card the emulator should emulate. Since Android
devices invariably have some form of "external storage", you probably
want to set up an SD card, by supplying a size in the associated field.
However, since a file will be created on your development machine
ofwhatever sizeyou specify for the card, you probably do not want to
create a 2GB emulated SD card. 32MB is a nice starting point, though you
can go larger if needed.
•
The "skin" or resolution the emulator should run in. The skin options you
have will depend upon what target you chose. The skins let you choose a
typical Android screen resolution (e.g., WVGA800 for 800x480). You can
also manually specify a resolution when you want to test a non-standard
configuration.
You can skip the "Hardware" section for now, as changing those settings is usually
only required for advanced configurations.
The resulting dialog might look something like this:
281
How To Get Started
Figure 58. Adding a New AVD (continued)
Click the CreateAVD button, and yourAVD stub will be created.
To start the emulator, highlight it in the list and click Start... You can skip the
launch options for now and just click Launch. The first time you launch a new
AVD, it will take a long time to start up. The second and subsequent times you
start theAVD, it will come up a bit faster, and usually you only need to start it up
once per day (e.g., when you start development). You do not need to stop and
restart the emulator every time you want to test your application, in most cases.
The emulator will go through a few startup phases, first with a plain-text
"ANDROID" label:
282
How To Get Started
Figure 59. Android emulator, initial startup segment
...then a graphical Android logo:
283
How To Get Started
Figure 60. Android emulator, secondary startup segment
before eventually landing at the home screen (the first time you run the AVD,
shown below) or the keyguard:
284
How To Get Started
Figure 61. Android home screen
If you get the keyguard (shown below), press the MENU button, or slide the green
lock on the screen to the right, to get to the emulator's home screen:
285
How To Get Started
Figure 62. Android keyguard
Set Up the Device
You do not need an Android device to get started in Android application
development. Having one is a good idea before you try to ship an application (e.g.,
upload it to the Android Market). And, perhaps you already have a device - maybe
that is what is spurring your interest in developing for Android.
The first step to make your device ready for use with development is to go into the
Settings application on the device. From there, choose Applications, then
Development. That should give you a set of checkboxes of development-related
options to consider:
286
How To Get Started
Figure 63. Android device development settings
Generally, you will want to enable USB debugging, so you can use your device with
the Android build tools. You can leave the other settings alone for now if you wish,
though you may find the "Stay awake" option to be handy, as it saves you from
having to unlock your phone all of the time while it is plugged into USB.
Next, you need to get your development machine set up to talk to your device.
That process varies by the operating system of your development machine, as is
covered in the following sections.
Step #1: Windows
When you first plug in your Android device, Windows will attempt to find a driver
for it. It is possible that, by virtue of other software you have installed, that the
driver is ready for use. If it finds a driver, you are probablyready to go.
287
How To Get Started
If the driver is not found, here are some options for getting one.
Windows Update
Some versions of Windows (e.g., Vista) will prompt you to search Windows
Update for drivers. This is certainly worth a shot, though not every device will
have supplied its driver to Microsoft.
Standard Android Driver
In your Android SDK installation, you will find a google-usb_driver directory,
containing a generic Windows driver for Android devices. You can try pointing the
driver wizard at this directory to see if it thinks this driver is suitable for your
device.
Manufacturer-Supplied Driver
If you still do not have a driver, search the CD that came with the device (if any) or
search the Web site of the device manufacturer. Motorola, for example, has drivers
available for all of their devices in one spot for download.
Step #2: OS X and Linux
Odds are decent that simply plugging in your device will "just work". You can see if
Android recognizes your device via running adb devices in a shell (e.g., OS X
Terminal), where adb is in your platform-tools/ directoryofyour SDK. If you get
output similar to the following, Android detected your device:
List of devices attached
HT9CPP809576 device
If you are running Ubuntu (or perhaps other Linux variants), and this command
did not work, you may need to add some udev rules. For example,
288
How To Get Started
here is a 51-android. rules file that will handle the devices from a handful of
manufacturers:
SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4",
SUBSYSTEM=="usb", SYSFS{idVendor}==M22b8",
SUBSYSTEM==Musb", SYSFS{idVendor}==M18d1",
SUBSYSTEMS==Musb", ATTRS{idVendor}==M18d1M, ATTRS{idProduct}==M0c01",
MODE=M0666", OWNER=M[me]M
SUBSYSTEM==MusbM, SYSFS{idVendor}==M19d2M,
SYSFS{idProduct}==M1354M,
SUBSYSTEM==MusbM, SYSFS{idVendor}==M04e8M,
SYSFS{idProduct}==M681cM,
M
MODE= 0666"
MODE="0666"
MODE="0666"
MODE=M0666M
MODE=M0666M
Drop that in your /etc/udev/rules.d directory on Ubuntu, then either reboot the
computer or otherwise reload the udev rules (e.g., sudo service udev reload).
Then, unplug and re-plug in the device and see if it is detected.
289
290
APPENDIX B
Coping with Eclipse
The author of this book is not an Eclipse user, which is why this book aims to be
agnostic in terms of development tools, unlike many other Android resources that
depict Eclipse as being mandatory.
That being said, Eclipse is a fine tool for Android development, but not everything
may be necessarily obvious. If you elect to use Eclipse, here are some tips for
getting around some of the Android aspects. Note that these tips are workarounds
cobbled together from assisting developers in live Android training sessions, and
so there may be better solutions available from true Eclipse experts.
How to Import a Non-Eclipse Project
Not all Android projects ship with Eclipse project files, such as the sample projects
associated with this book. However, these can still be easily added to your Eclipse
workspace, if you wish. Here is how to do it!
First, choose File > New > Project... from the Eclipse main menu:
291
Coping with Eclipse
Figure 64. File menu in Eclipse
Then, choose Android > Android Project from the tree of available project types:
292
Coping with Eclipse
Figure 65. New project wizard in Eclipse
Note: if you do not see this option, you have not installed the Android
DeveloperTools.
Then, in the next page of the project creation wizard, choose the "Create project
from existing source" radio button, click the [Browse...] button, and open the
directory containingyour project's AndroidManifest.xml file. This will populate
most of the rest of this screen, though you may need to also specify a build target
from the table:
293
Coping with Eclipse
Figure 66. Android project wizard in Eclipse
Then, click [Finish]. This will return you to Eclipse, with the imported project in
your workspace:
294
Coping with Eclipse
Figure 67. Android project tree in Eclipse
Next, right-click over the project name, and choose Build Path > Configure Build
Path from the context menu:
Figure 68. Project context menu in Eclipse
295
Coping with Eclipse
This brings up the build path portion of the project properties window:
Figure 69. Project properties window in Eclipse
If the Android JAR is not checked (see the Android 2.2 entry in the above image),
check it, then close the properties window. At this point, your project should be
ready for use.
How to Get To DDMS
Many times, you will be told to take a look at something in DDMS, such as the
LogCat tab to examine Java stack traces. In Eclipse, DDMS is a perspective. To
open this perspective in your workspace, choose Window > Open Perspective >
Other... from the main menu:
296
Coping with Eclipse
Figure 70. Perspective menu in Eclipse
Then, in the list of perspectives, choose DDMS:
297
Coping with Eclipse
Figure 71. Perspective roster in Eclipse
This will add the DDMS perspective to your workspace and open it in your Eclipse
IDE.
How to Create an Emulator
By default, your Eclipse environment has no Android emulators set up. You will
need one before you can run your project successfully.
To do this, first choose Window > Android SDK and AVD Manager from the main
menu:
298
Coping with Eclipse
Figure 72. Android AVD Manager menu option in Eclipse
That brings up the same window as you can get by running android from the
command line.
How to Run a Project
Given that you have an AVD defined, or that you have a device set up for
debugging and connected to your development machine, you can run your project
in the emulator.
First, click the Run toolbar button, or choose Project > Run from the main menu.
This will bring up the "Run As" dialog the first time you run the project:
299
Coping with Eclipse
Figure 73. Android AVD Manager menu option in Eclipse
Choose Android Application and click OK. If you have more than one AVD or
device available, you will be presented with a window where you choose the
desired target environment. Then, the emulator will start up to run your
application. Note that you will need to unlock the lock screen on the emulator (or
device) if it is locked.
How Not to Run Your Project
When you go to run your project, be sure to not have an XML file be the active tab
in the editor. Attempting to "run" this will result in a .out file being created in
whatever directory the XML file lives in (e.g., res/layout/main.xml.out). To recover,
simply delete the offending .out file and try running again, this time with a Java
file as the active tab.
How to Get Past Eclipse
Some people will tell you that the only sensible way to do Android development is
to use Eclipse. These people are sorely mistaken.
300
Coping with Eclipse
Eclipse - whether with the basic Android add-on or the full-blown MOTODEV
Studio for Android - is a fine Java IDE. It is not the only Java IDE. And, many
developers are able to get by quite nicely without an IDE.
If you are used to using Eclipse, stick with it.
If you are used to working outside of Eclipse, you are welcome to give that a try
and perhaps continue to work outside of Eclipse. There is nothing in Android
development that can only be done with Eclipse. IntelliJ's IDEA, for example, has
Android support as an integrated add-on that ships with their product, so if you
are using IDEA, there is no particular reason to change. Or, you are welcome to
avoid an IDE altogether, as many developers do, including the author of this book.
Do not beafraid to try Eclipse, butat the same time, do not feelcompelled to use
Eclipse.
301
302
Keyword Index
Class ....................................................
ContentValues ......................................................................... 97
Criteria .................................................................................... 215
Activity ............16, 17, 38, 49, 69, 86, 171, 172, 184, 192, 251
Adapter ..................................................................................... 45
AdapterView.OnltemClickListener.......................................... 51
Cursor....................................... 96-101, 123, 143, 155, 197, 222
CursorAdapter ................................................... 93, 98, 99, 101
DatePicker ............................................................................... 56
AlarmActivity .................... 251-253, 256, 260, 262, 266, 268
DatePickerDialog..................................................................... 56
AlarmManager .................. 237, 242, 244-246, 251, 253, 258
AlertDialog ...................................................... 67, 132, 169, 216
ArrayAdapter ........................................33, 93, 98, 99, 170, 171
DetailForm... .109-111, 113, 115-120, 122, 124, 128, 130, 147, 148,
160-163, 200, 201, 204, 206-209, 216, 218, 220, 222, 224
DetailsForm .......................................................... 192, 193, 206
ArrayList ....................................................... 33, 52, 96, 99-101
AsyncTask........................................ 76, 169, 171, 181, 186, 188
DialogPreference ..........................................................238, 240
Drawable ....................................................................... 229, 230
AtomicBoolean ......................................................................... 78
AutoCompleteTextView .......................................................... 36
BaseAdapter .................................................................... 170, 171
BroadcastReceiver .............................. 242-244, 246, 251, 252
EditPreferences .................. 137-139, 238, 242, 248, 249, 260
EditText...................... 16-18, 20, 36, 45, 57, 59, 90, 158-160
EditTextPreference ................................................................ 257
ErrorDialog .............................................................................. 67
Bundle .................................................................... 147, 148, 172
Button ........................................................ 17, 30, 56, 158, 200
Calendar ................................................................................ 246
CheckBoxPreference ................................... 241, 242, 244, 260
Connect ivityManager ........................................................... 163
303
Exception ....................................................................... 169, 185
FakeJob..................................................................................... 75
FeedActivity ......... 163, 167-174, 178, 179, 184, 186-189, 192,
193 FeedAdapter ............................................................. 170, 173
FeedHandler .................................................................. 186, 187
Keyword Index
FeedService ....................................................183-186, 188, 192
NotificationManager .................................................... 259, 262
FeedTask ................................168, 169, 171-174, 183, 186, 187
OnAlarmReceiver ....................... 246, 251-253, 260-262, 266
FrameLayout .................................................................... 47, 49
OnBootReceiver................................................... 243-247, 249
Geocoder ................................................................................ 216
OnltemClickListener .............................................................200
GeoPoint....................................................................... 228, 229
OnSharedPreferenceChangeListener ......................... 248, 249
Handler................................................... 75, 169, 184, 186, 187
Overlay ................................................................................... 229
HttpClient .............................................................................. 166
Overlayltem ................................................................... 229-231
HttpUrlConnection ............................................................... 166
PackageManager ................................................................... 249
ImageView................................................................................ 41
Parcelable ............................................................................... 184
InstanceState .................................................. 172, 173, 187, 188
PendingIntent ......................................192, 246, 251, 253, 262
Intent .......111, 116, 118, 174, 183-185, 192, 217, 222, 223, 252
Preference ............................................................................. 240
IntentService ........................................................... 181-183, 192
PreferenceActivity ..........................................................135, 136
ItemizedOverlay ........................................................... 221, 229
PreferenceScreen ............................................................135, 136
KillJob ...................................................................................... 76
ProgressBar ..............................................................................69
LinearLayout ...............................................18, 20, 39, 90, 203
RadioButton ......................................................... 21, 22, 24, 26
LinkedBloc kingQueue ............................................................ 75
RadioGroup ....................................................................... 22, 26
List ................................................................................... 99, 170
RelativeLayout ................................................................... 31, 47
ListActivity ...................................................... 115, 116, 153, 167
RestaurantAdapter .............................. 38, 40, 42, 97-100, 115
ListAdapter............................................................................... 37
RestaurantHelper. .94-96 , 98 , 101,105 , 117,120 , 130, 141, 143,
153-155, 160, 195-198, 204, 209, 236
ListView .............. 29, 31, 33, 36, 37, 47, 51, 115, 170, 173, 179
RestaurantHolder ..................................................... 37, 42, 100
LocationListener .......................................................... 207, 208
RestaurantMap ..................................... 219-222, 228-231, 236
LocationManager .......................................................... 195, 206
RestaurantOverlay ........................................................ 229, 230
LunchList...xxii, 29, 33, 38, 41, 42, 49, 51, 53, 58-60, 62, 63, 69,
71, 72, 78, 81, 87, 88, 93, 95-97, 99-102, 110, 111, 113, 115, 116, 118120, 123, 126, 128, 138, 142, 216
ResultReceiver ....................................................................... 192
RSSFeed.......................................... 169, 170, 172-174, 183, 185
MapActivity ............................................................ 217-219, 235
RSSItem ....................................................................................171
MapController....................................................................... 228
RSSReader .............................................................. 169,183, 188
MapView ............................................................... 217, 221, 228
Runnable ........................................................ 71, 74, 77, 78, 95
MenuInflate4........................................................................... 161
ScrollView ................................................................................ 26
Message .......................................................................... 185, 186
Service .....................................................................................182
Messenger ..................................................... 184, 185, 187, 192
Notification ........................................ 259-262, 264-266, 268
304
Keyword Index
android update project -p ..................................................... xvii
SharedPreferences .......... 136, 142, 238, 240, 245, 248, 249,
260, 262
ant -version ............................................................................ 279
Spinner ..................................................................................... 36
ant clean.................................................................................... 21
SQLiteDatabase ................................................................ 97, 98
ant install ............................................................................ 18, 21
SQLiteOpenHelper .................................................................. 93
ant reinstall .............................................................................. 26
String ....................................................... 57, 116, 184, 222, 241
cron ........................................................................................ 242
TabActivity ....................................................................... 49, 115
pdftk *.pdf cat output combined.pdf. ................................... xiv
TabHost............................................................................. 47, 49
sqlite3 ...................................................................................... 107
TableLayout .......................................... 19, 20, 22, 27, 58, 158
sudo ........................................................................................ 269
TableRow ................................................................. 20, 58, 202
sudo service udev reload ....................................................... 289
TabView ................................................................................... 47
TabWidget
47
............................................. Method
TextView .................................................. 18, 41, 202-204, 222
android list targets .....................................................................5
Thread ........................................................................ 75, 76, 78
add() ...........................................................................................33
TimePicker .................................................................... 240, 255
addView() ................................................................................ 26
TimePreference ................................... 238, 240-242, 255, 257
attach()............................................................................ 171, 186
Toast ................... 57, 61, 62, 67, 163, 179, 208, 215, 231, 234
bindView() ............................................................................... 99
tools/.......................................................................................279
boundCenterBottom() .......................................................... 229
TypedArray ............................................................................ 241
cancelAlarm() .............................................................. 246, 249
Vibrator .................................................................................. 257
detach() ........................................................................... 171, 186
View ................................................................................ 99, 240
doInBackground() ................................................. 169, 183, 186
View .OnClickListener.............................................................. 17
doSomeLongWork() ................................................... 71, 74, 95
ViewFlipper .............................................................................. 56
findViewById() .................................................................17, 160
finish() .....................................................................................120
Command ...........................................
adb devices ............................................................................ 288
adb logcat .................................................................................. 21
adb pull .................................................................................. 106
adb shell ................................................................................. 107
android ..........................................................................272, 299
getActiveNetworkInfo() ......................................................... 163
getActivity() .................................................................. 253, 262
getAll() ....................................100, 141-143, 154, 155, 196, 197
getById() ........................................................ 154, 155, 196, 197
getCheckedRadioButtonId() ................................................... 26
getCount() ............................................................................... 171
getFeed() ................................................................................. 155
305
Keyword Index
getHour() .............................................................................. 240
onGetDefaultValue() ..............................................................241
getltem() ......................................................................... 171, 230
onHandleIntent() .................................................. 182-184, 192
getltemld() .............................................................................. 171
onItemClick() .......................................................................... 52
getltems() ............................................................................... 170
onListItemClick() ................................................................... 116
get ItemViewType() ................................................................. 45
onLocationChanged() ........................................................... 207
getLastNonConfigurationInstance() ..................... 172, 173, 188
onOptionsItemSelected()....62, 72, 73, 95, 119, 138, 162, 163,
206, 220, 222, 223 onPause().
getMinute() ........................................................................... 240
......................................................... 78, 79, 95, 201, 208, 249
get PendingIntent() .............................................................. 246
onPostExecute() ............................................. 169, 171, 173, 186
getSystemService() ..................................... 163, 206, 245, 262
onPrepareOptionsMenu()............................ 179, 209, 216, 218
get ag()
T
........................................................................................42
onReceive() .................................................. 243, 245, 247, 261
getView() ...........................................................................42, 99
onRestoreInstanceState().............................................. 148,172
getViewTypeCount() ............................................................... 45
onResume()............................................... 78, 79, 95,144, 249
getWritableDatabase() ............................................................97
onRetainNonConfigurationInstance() 150, 172, 173, 187
goBlooey() ..................................................................... 169, 186
onSaveInstanceState() ...................... 86, 91, 147, 148, 150, 172
handleMessage() ............................................................184, 186
onSetInit ialValue () ...............................................................241
initList() ......................................................................... 143, 144
onSharedPreferenceChanged() .............................................249
insert() .............................................. 96, 97, 101, 154, 160, 197
onStart() ................................................................................... 86
isNetworkAvailable() ............................................................. 162
onStop() ................................................................................... 86
isRouteDisplayed() ............................................................... 220
onTap() .................................................................................. 230
load() .............................................................118, 160, 204, 222
onUpgrade() .................................................... 94, 95, 154, 196
newView() ............................................................................... 99
populate() .............................................................................. 229
notify() ................................................................................... 262
rawQuery() .............................................................................. 98
onBindDialogView() ..................................................... 240, 241
registerOnSharedPreferenceChange Listener() ...................249
onClick()............................................................ 31, 51, 160, 200
requestLocationUpdates() ...........................................206, 207
onCreate()..38, 49, 51, 59, 69, 75, 86, 91, 94-96, 99, 113, 115, 117,
118, 142, 143, 148, 153, 160, 172-174, 188, 196, 204, 206, 220, 228,
230, 236
requestWindowFeature() ........................................................ 95
runO nUiThread () .................................................................. 74
onCreateDialogView() .......................................................... 240
save() ..................................................................... 120, 200, 201
onCreateOptionMenu() ......................................................... 119
send() ............................................................................. 185, 192
onCreateOptionsMenu() ......................................... 95, 161, 216
setAlarm() .....................................................................245, 249
onDestroy() ...................................................................... 96, 117
onDialogClosed() ............................................................. 240
306
Keyword Index
setComponentEnabledSetting() ........................................... 249
setContentView() .........................................51, 69, 96, 110, 113
setFeed() ................................................................ 169, 173, 186
setLatestEventInfo() ............................................................. 262
setListAdapter() ...................................................................... 115
setOnItemClickListener() ........................................................ 51
setRepeating() ....................................................................... 246
setTag() .....................................................................................42
size() ...................................................................................... 229
sleep() .................................................................................... 192
startActivity() ....................... 111, 132, 220, 252, 253, 261, 262
startManagingCursor() .......................................................... 100
startService() .......................................................................... 188
startWork()....................................................................... 79, 95
stopManagingCursor()........................................................... 143
toString() ................................................................................... 31
update() ......................................................... 120, 154, 160, 197
updateLocation() .......................................................... 197,209
307