IT

Beginning Android 3.pdf

DownLoad Book

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


Tags: android

默认图片

书名: Beginning Android 3

作者: Mark Murphy

出版日期: July 5, 2011

页数: 612

ISBN: 978-1-4302-3297-1

Extracting password :d8a9e1bd80bf15d4


CHAPTER 9: Super Jumper: A 2D OpenGL ES Game
488
For your convenience Apress has placed some of the front
matter material after the index. Please use the Bookmarks
and Contents at a Glance links to access them.
iii
Contents at a Glance
Contents .............................................................................................................. v
About the Author ............................................................................................... xvi
About the Technical Reviewer ......................................................................... xvii
Acknowledgments .......................................................................................... xviii
Preface ............................................................................................................. xix
Part I: Core Concept ............................................................................................ 1
Chapter 1: The Big Picture ............................................................................... 3
Chapter 2: How to Get Started ......................................................................... 7
Chapter 3: Your First Android Project ........................................................... 23
Chapter 4: Examining Your First Project ....................................................... 31
Chapter 5: A Bit About Eclipse ....................................................................... 37
Chapter 6: Enhancing Your First Project ....................................................... 47
Part II: Activities ............................................................................................... 49
Chapter 7: Rewriting Your First Project ........................................................ 51
Chapter 8: Using XML-Based Layouts ........................................................... 55
Chapter 9: Employing Basic Widgets ............................................................. 61
Chapter 10: Working with Containers ........................................................... 73
Chapter 11: The Input Method Framework .................................................... 93
Chapter 12: Using Selection Widgets .......................................................... 103
Chapter 13: Getting Fancy with Lists .......................................................... 119
Chapter 14: Still More Widgets and Containers ........................................... 135
Chapter 15: Embedding the WebKit Browser .............................................. 159
Chapter 16: Applying Menus ....................................................................... 167
Chapter 17: Showing Pop-Up Messages ...................................................... 179
Chapter 18: Handling Activity Lifecycle Events ........................................... 183
Chapter 19: Handling Rotation .................................................................... 187
Chapter 20: Dealing with Threads ............................................................... 203
CONTENTS AT A GLANCE
iv
Chapter 21: Creating Intent Filters .............................................................. 221
Chapter 22: Launching Activities and Subactivities ................................... 227
Chapter 23: Working with Resources .......................................................... 235
Chapter 24: Defining and Using Styles ........................................................ 251
Chapter 25: Handling Multiple Screen Sizes ............................................... 257
Part III: Honeycomb and Tablets ..................................................................... 279
Chapter 26: ntroducing the Honeycomb UI .................................................. 281
Chapter 27: Using the Action Bar ................................................................ 289
Chapter 28: Fragments ................................................................................ 297
Chapter 29: Handling Platform Changes ..................................................... 313
Chapter 30: Accessing Files ........................................................................ 323
Part IV: Data Stores, Network Services, and APIs .......................................... 337
Chapter 31: Using Preferences .................................................................... 339
Chapter 32: Managing and Accessing Local Databases .............................. 357
Chapter 33: Leveraging Java Libraries ....................................................... 369
Chapter 34: Communicating via the Internet .............................................. 377
Part V: Services .............................................................................................. 393
Chapter 35: Services: The Theory ................................................................ 395
Chapter 36: Basic Service Patterns ............................................................. 403
Chapter 37: Alerting Users via Notifications ............................................... 423
Part VI: Other Android Capabilities ................................................................. 435
Chapter 38: Requesting and Requiring Permissions ................................... 437
Chapter 39: Accessing Location-Based Services ........................................ 443
Chapter 40: Mapping with MapView and MapActivity ................................ 449
Chapter 41: Handling Telephone Calls ......................................................... 463
Chapter 42: Fonts ........................................................................................ 467
Chapter 43: More Development Tools ......................................................... 473
Part VII: Alternative Application Environments .............................................. 489
Chapter 44: The Role of Alternative Environments ...................................... 491
Chapter 45: HTML5 ...................................................................................... 495
Chapter 46: PhoneGap ................................................................................. 507
Chapter 47: Other Alternative Environments ............................................... 523
Part VIII: The Ever-Evolving Android .............................................................. 529
Chapter 48: Dealing with Devices ................................................................ 531
Chapter 49: Where Do We Go From Here? ................................................... 537
Index ............................................................................................................... 541
Part
Core Concept
I
3
Chapter
The Big Picture
Android is everywhere. Phones. Tablets. TVs and set-top boxes powered by Google TV.
Soon, Android will be in cars and all sort of other places as well.
However, the general theme of Android devices will be smaller screens and/or no
hardware keyboard. And, by the numbers, Android will probably be associated mostly
with smartphones for the foreseeable future. For developers, this has both benefits and
drawbacks, as described next. This chapter also describes the main components in an
Android application and the Android features that you can exploit when developing your
applications.
Benefits and Drawbacks of Smartphone
Programming
On the plus side, Android-style smartphones are sexy. Offering Internet services over
mobile devices dates back to the mid-1990s and the Handheld Device Markup
Language (HDML). However, only in recent years have phones capable of Internet
access taken off. Now, thanks to trends like text messaging and products like Apple’s
iPhone, phones that can serve as Internet-access devices are rapidly gaining popularity.
So, working on Android applications gives you experience with an interesting technology
(Android) in a fast-moving market segment (Internet-enabled phones), which is always a
good thing.
The problem comes when you actually have to program the darn things.
Anyone with experience in programming for PDAs or phones has felt the pain of phones
simply being small in all sorts of dimensions:
Screens are small (you will not get comments like, “Is that a 24-inch
LCD in your pocket, or...?”).
Keyboards, if they exist, are small.
1
CHAPTER 1: The Big Picture
4
Pointing devices, if they exist, are annoying (as anyone who has lost
their stylus will tell you) or inexact (large fingers and “multitouch” LCDs
can sometimes be...problematic).
CPU speed and memory are limited compared to what’s available on
desktops and servers.
Moreover, applications running on a phone have to deal with the fact that they’re on a
phone.
People with mobile phones tend to get very irritated when those phones do not work.
Similarly, those same people will get irritated if your program “breaks” their phones by
Tying up the CPU such that calls can’t be received.
Not quietly fading into the background when a call comes in or needs
to be placed, because the program doesn’t work properly with the rest
of the phone’s operating system.
Crashing the phone’s operating system, such as by leaking memory
like a sieve.
Hence, developing programs for a phone is a different experience than developing
desktop applications, web sites, or back-end server processes. The tools look different,
the frameworks behave differently, and you have more limitations on what you can do
with your programs.
What Android tries to do is meet you halfway:
You get a commonly used programming language (Java) with some
commonly used libraries (e.g., some Apache Commons APIs), with
support for tools you may be used to using (Eclipse).
You get a fairly rigid and uncommon framework in which your
programs need to run so they can be “good citizens” on the phone
and not interfere with other programs or the operation of the phone
itself.
As you might expect, much of this book deals with that framework and how you write
programs that work within its confines and take advantage of its capabilities.
What Androids Are Made Of
When you write a desktop application, you are “master of your own domain.” You
launch your main window and any child windows—like dialog boxes—that are needed.
From your standpoint, you are your own world, leveraging features supported by the
operating system, but largely ignorant of any other program that may be running on the
computer at the same time. If you do interact with other programs, it is typically through
an application programming interface (API), such as Java Database Connectivity (JDBC),
or frameworks atop it, to communicate with MySQL or another database.
CHAPTER 1: The Big Picture
5
Android has similar concepts, but they are packaged differently and structured to make
phones more crash-resistant:
Activities: The building block of the user interface is the activity. You
can think of an activity as being the Android analogue for the window
or dialog box in a desktop application or the page in a classic web
application. Android is designed to support lots of cheap activities, so
you can allow users to keep tapping to open new activities and
tapping the Back button to back up, just like they do in a web browser.
Services: Activities are short-lived and can be shut down at any time.
Services, on the other hand, are designed to keep running, if needed,
independent of any activity. You might use a service to check for
updates to an RSS feed or to play back music even if the controlling
activity is no longer operating. You will also use services for scheduled
tasks (“cron jobs”) and for exposing custom APIs to other applications
on the device, though those are relatively advanced capabilities.
Content providers: Content providers provide a level of abstraction for
any data stored on the device that is accessible by multiple
applications. The Android development model encourages you to
make your own data available to other applications, as well as your
own applications. Building a content provider lets you do that, while
maintaining complete control over how your data gets accessed.
Intents: Intents are system messages that run around the inside of the
device and notify applications of various events, from hardware state
changes (e.g., an SD card was inserted), to incoming data (e.g., a
Short Message Service [SMS] message arrived), to application events
(e.g., your activity was launched from the device’s main menu). Not
only can you respond to an Intent, but you can create your own to
launch other activities or to let you know when specific situations arise
(e.g., raise such-and-so Intent when the user gets within 100 meters
of this-and-such location).
Stuff at Your Disposal
Storage: You can package data files with your application for things
that do not change, such as icons or help files. You also can carve out
a small bit of space on the device itself, for databases or files
containing user-entered or retrieved data needed by your application.
And, if the user supplies bulk storage, like an SD card, you can read
and write files on there as needed.
CHAPTER 1: The Big Picture
6
Network: Android devices generally are Internet-ready, through one
communications medium or another. You can take advantage of the
Internet access at any level you wish, from raw Java sockets all the
way up to a built-in WebKit-based web browser widget you can
embed in your application.
Multimedia: Android devices have the ability to play back and record
audio and video. While the specifics may vary from device to device,
you can query the device to learn its capabilities and then take
advantage of the multimedia capabilities as you see fit, whether that is
to play back music, take pictures with the camera, or use the
microphone for audio note-taking.
Global Positioning System (GPS): Android devices frequently have
access to location providers, such as GPS, that can tell your
applications where the device is on the face of the Earth. In turn, you
can display maps or otherwise take advantage of the location data,
such as to track a device’s movements if the device has been stolen.
Phone services: Because Android devices are typically phones, your
software can initiate calls, send and receive SMS messages, and do
everything else you expect from a modern bit of telephony technology.
The Big Picture...of This Book
Now that you have the Android big picture, here is what’s coming in the rest of this
book:
The next two chapters are designed to get you going quickly with the
Android environment, through a series of step-by-step, tutorial-style
instructions for setting up the tools you need, creating your first
project, and getting that first project running on the Android emulator.
The three chapters that follow explain a bit more about what just
happened in Chapters 2 and 3. We examine the Android project that
we created, talk a bit more about Eclipse, and discuss some things we
could add to the project to help it run on more devices and enhance its
capabilities.
The bulk of the book explores the various capabilities of the Android
APIs—how to create components like activities, how to access the
Internet and local databases, how to get your location and show it on
a map, and so forth.
7
Chapter
How to Get Started
Without further ado, let’s get you set up with the pieces and parts necessary to build an
Android app.
NOTE: The instructions presented here are accurate as of the time of this writing. However, the
tools change rapidly, so these instructions may be out of date by the time you read this. Please
refer to the Android Developers web site for current instructions, using this as a base guideline of
what to expect.
Step 1: Set Up Java
When you write Android applications, you typically write them in Java source code. That
Java source code is then turned into the stuff that Android actually runs (Dalvik
bytecode in an Android package [APK] file).
Hence, the first thing you need to do is get set up with a Java development environment
so that you are prepared to start writing Java classes.
Install the JDK
You need to obtain and install the official 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 Mac OS X. The plain JDK (sans any “bundles”) should suffice. Follow the
instructions supplied by Oracle or Apple for installing it on your machine. At the time of
this writing, Android supports Java 5 and Java 6, the latter being the now-current
edition.
Alternative Java Compilers
In principle, you are supposed to use the official Sun/Oracle Java SE Development Kit
(JDK) In practice, it appears that OpenJDK also works, at least on Ubuntu. However, the
2
CHAPTER 2: How to Get Started
8
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.
Learn Java
This book, like most books and documentation on Android, assumes that you have
basic Java programming experience. If you lack this, you really should consider
spending a bit of time on Java fundamentals, before you dive into Android. Otherwise,
you may find the experience to be frustrating.
If you are in need of a crash course in Java to get involved in Android development, here
are the concepts you need to learn, presented in no particular order:
Language fundamentals (flow control, etc.)
Classes and objects
Methods and data members
Public, private, and protected
Static and instance scope
Exceptions
Threads and concurrency control
Collections
Generics
File I/O
Reflection
Interfaces
One of the easiest ways of acquiring this knowledge is to read Learn Java for Android
Development by Jeff Friesen (Apress, 2010).
Step 2: Install the Android SDK
The Android SDK gives you all the tools you need to create and test Android
applications. It comes in two parts: the base tools, and version-specific SDKs and
related add-ons.
Install the Base Tools
You can find the Android developer tools on the Android Developers web site. Download
the ZIP file that is appropriate for your platform and unzip it in a logical location on your
CHAPTER 2: How to Get Started
9
machineno specific path is required. Windows users also have the option of running a
self-installing EXE file.
Install the SDKs and Add-ons
Inside the tools/ directory of your Android SDK installation from the previous step, you
will see an android batch file or shell script. If you run that, you will be presented with
the Android SDK and AVD Manager, shown in Figure 2–1.
Figure 2–1. Android SDK and AVD Manager
At this point, you have some of the build tools, but you lack the Java files necessary to
compile an Android application. You also lack a few additional build tools, and the files
necessary to run an Android emulator. To address this, click the Available packages
option on the left to open the screen shown in Figure 2–2.
CHAPTER 2: How to Get Started
10
Figure 2–2. Android SDK and AVD Manager available packages
Open the Android Repository branch of the tree. After a short pause, you will see a
screen similar to Figure 2–3.
Figure 2–3. Android SDK and AVD Manager available Android packages
Check the boxes for the following items:
“SDK Platform” for all Android SDK releases you want to test against
“Documentation for Android SDK” for the latest Android SDK release
“Samples for SDK” for the latest Android SDK release, and perhaps for
older releases if you wish
Then, open the Third party Add-ons branch of the tree. After a short pause, you will see
a screen similar to Figure 2–4.
CHAPTER 2: How to Get Started
11
Figure 2–4. Android SDK and AVD Manager available third-party add-ons
Click the “Google Inc. add-ons” branch to open it, as shown in Figure 2–5.
Figure 2–5. Android SDK and AVD Manager available Google add-ons
Most likely, you will want to check the boxes for the “Google APIs by Google Inc.” items
that match up with the SDK versions you selected in the Android Repository branch. The
Google APIs include support for Google Maps, both from your code and in the Android
emulator.
After you have checked all the items you want to download, click the Install Selected
button, which brings up a license confirmation dialog box, shown in Figure 2–6.
CHAPTER 2: How to Get Started
12
Figure 2–6. Android SDK and AVD Manger license agreement screen
Review and accept the licenses if you agree with the terms, and then click the Install
button. At this point, this is a fine time to go get lunch or dinner. Unless you have a
substantial Internet connection, downloading all of this data and unpacking it will take a
fair bit of time.
When the download is complete, you can close the SDK and AVD Manager if you wish,
though you will use it to set up the emulator in Step 5 of this chapter.
Step 3: Install the ADT for Eclipse
If you will not be using Eclipse for your Android development, you can skip to the next
section. If you will be using Eclipse but have not yet installed it, you will need to do that
first. Eclipse can be downloaded from the Eclipse web site, www.eclipse.org/. The
Eclipse IDE for Java Developers package will work fine.
Next, you need to install the Android Developer Tools (ADT) plug-in. To do this, open
Eclipse and choose Help
Install New Software. Then, in the Install dialog box, click the
Add button to add a new source of plug-ins. Give it a name (e.g., Android) and supply
the following URL: https://dl-ssl.google.com/android/eclipse/. That should trigger
Eclipse to download the roster of plug-ins available from that site (see Figure 2–7).
CHAPTER 2: How to Get Started
13
Figure 2–7. Eclipse ADT plug-in installation
Check the Developer Tools check box and click the Next button. Follow the rest of the
wizard steps to review the tools to be downloaded and review and accept their respective
license agreements. When the Finish button is enabled, click it, and Eclipse will download
and install the plug-ins. When it’s done, Eclipse will ask to restart; let it do so.
Then, you need to show ADT where to locate your Android SDK installation from the
preceding section. To do this, choose Window
Preferences from the Eclipse main
menu (or the equivalent Preferences option for Mac OS X). Click the Android entry in the
list pane of the Preferences dialog box, as shown in Figure 2–8.
CHAPTER 2: How to Get Started
14
Figure 2–8. Eclipse ADT configuration
Then, click the Browse button to find the directory where you installed the SDK. After
choosing it, click Apply in the Preferences dialog box, and you should see the Android
SDK versions you installed previously. Then, click OK, and the ADT will be ready for use.
Step 4: Install Apache Ant
If you will be doing all of your development from Eclipse, you can skip to the next
section. If you wish to develop using command-line build tools, you need to install
Apache Ant. You may have this installed already from previous Java development work,
as it is fairly common in Java projects. However, you need Ant version 1.8.1 or later, so
check your current copy (e.g., ant -version).
If you do not have Ant or do not have the correct version, you can obtain it from the
Apache Ant web site, at http://ant.apache.org/. Full installation instructions are
available in the Ant manual, but the basic steps are as follows:
1. Unpack the ZIP archive in a logical place on your machine.
2. Add a JAVA_HOME environment variable, pointing to where your JDK is
installed, if you do not have one already.
3. Add an ANT_HOME environment variable, pointing to the directory where
you unpacked Ant in step 1.
CHAPTER 2: How to Get Started
15
4. Add $JAVA_HOME/bin and $ANT_HOME/bin to your PATH.
5. Run ant -version to confirm that Ant is installed properly.
Step 5: Set Up the Emulator
The Android tools include an emulator, a piece of software that pretends to be an
Android device. This is very useful for development—it not only enables you to get
started on your Android development without a device, but also enables you to test
device configurations for devices that you do not own.
The Android emulator can emulate one or several Android devices. Each configuration
you want is stored in an Android Virtual Device (AVD). The Android SDK and AVD
Manager, which you used to download the SDK components earlier in this chapter, is
where you create these AVDs.
If you do not have the SDK and AVD Manager running, you can run it via the android
command from your SDK’s tools/ directory, or via Window
SDK and AVD Manager
from Eclipse. It opens with a screen listing the AVDs you have available; initially, the list
will be empty, as shown in Figure 2–9.
Figure 2–9. Android SDK and AVD Manager Android Virtual Devices list
Click the New button to create a new AVD file. This opens the dialog box shown in
Figure 2–10, where you can configure how this AVD should look work.
CHAPTER 2: How to Get Started
16
Figure 2–10. Adding a new AVD
You need to provide the following:
A name for the AVD: Since the name goes into files on your
development machine, you are limited by the file name conventions for
your operating system (e.g., no backslashes on Windows).
The Android version (target) you want the emulator to run: Choose one
of the SDKs you installed via the Target drop-down list. Note that in
addition to “pure” Android environments, you will have options based
on the third-party add-ons you selected. For example, you probably
have some options for setting up AVDs containing the Google APIs,
and you will need such an AVD for testing an application that uses
Google Maps.
Details about the SD card the emulator should emulate: Since Android
devices invariably have some form of external storage, you probably
want to set up an SD card, by supplying a size in the associated field.
However, since a file will be created on your development machine of
whatever size you specify for the card, you probably do not want to
create a 2GB emulated SD card. 32MB is a nice starting point, though
you can go larger if needed.
CHAPTER 2: How to Get Started
17
The “skin” or resolution the emulator should run in: The skin options
you have available depend upon what target you chose. The skins let
you choose a typical Android screen resolution (e.g., WVGA800 for
800480). You can also manually specify a resolution when you want
to test a nonstandard configuration.
You can skip the Hardware section of the dialog box for now, as changing those
settings is usually only required for advanced configurations.
The resulting dialog box might look something like Figure 2–11.
Figure 2–11. Adding a new AVD (continued)
Click the Create AVD button, and your AVD stub will be created.
To start the emulator, select it in the Android Virtual Devices list and click Start. You can
skip the launch options for now and just click Launch. The first time you launch a new
AVD, it will take a long time to start up. The second and subsequent times you start the
AVD, it will come up a bit faster, and usually you need to start it only once per day (e.g.,
when you start development). You do not need to stop and restart the emulator every
time you want to test your application, in most cases.
The emulator will go through a few startup phases, the first of which displays a plain-text
ANDROID label, as shown in Figure 2–12.
CHAPTER 2: How to Get Started
18
Figure 2–12. Android emulator, initial startup segment
The second phase displays a graphical Android logo, as shown in Figure 2–13.
CHAPTER 2: How to Get Started
19
Figure 2–13. Android emulator, secondary startup segment
Finally, the emulator reaches the home screen (the first time you run the AVD; see Figure
214) or the keyguard (see Figure 2–15).
CHAPTER 2: How to Get Started
20
Figure 2–14. Android home screen
If you get the keyguard, press the Menu button or slide the green lock on the screen to
the right, to get to the emulator’s home screen.
Figure 2–15. Android keyguard
CHAPTER 2: How to Get Started
21
Step 6: Set Up the Device
With an emulator set up, 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). But 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 check boxes for choosing development-related options,
similar to what’s shown in Figure 2–16.
Figure 2–16. Android device development settings
Generally, you will want to enable USB debugging so that 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 repeatedly while it is plugged into USB.
Next, you need to set up your development machine to talk to your device. That process
varies by the operating system of your development machine, as covered in the
following sections.
Windows
When you first plug in your Android device, Windows attempts to find a driver for it. It is
possible that, by virtue of other software you have installed, the driver is ready for use. If
Windows finds a driver, you are probably ready to go.
If Windows doesn’t find the driver, here are some options for getting one:
Windows Update: Some versions of Windows (e.g., Vista) 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.
CHAPTER 2: How to Get Started
22
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 its devices in one spot for download.
Mac OS X and Linux
Odds are decent that simply plugging in your device will “just work.” You can see if
Android recognizes your device by running adb devices in a shell (e.g., OS X Terminal),
where adb is in your platform-tools/ directory of your 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 another Linux variant) and this command did not
work, you may need to add some udev rules. For example, here is a 51-android.rules
file that will handle the devices from a handful of manufacturers:
SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4", MODE="0666"
SUBSYSTEM=="usb", SYSFS{idVendor}=="22b8", MODE="0666"
SUBSYSTEM=="usb", SYSFS{idVendor}=="18d1", MODE="0666"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="18d1", ATTRS{idProduct}=="0c01", MODE="0666",
OWNER="[me]"
SUBSYSTEM=="usb", SYSFS{idVendor}=="19d2", SYSFS{idProduct}=="1354", MODE="0666"
SUBSYSTEM=="usb", SYSFS{idVendor}=="04e8", SYSFS{idProduct}=="681c", MODE="0666"
Drop that in your /etc/udev/rules.d directory on Ubuntu, and then either reboot the
computer or otherwise reload the udev rules (e.g., sudo service udev reload). Then,
unplug the device, plug it in again, and see if it is detected.
23
Chapter
Your First Android Project
Now that 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 watch it open on your emulator or device.
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. The process differs depending on
whether you are using Eclipse or the command line.
Eclipse
From the Eclipse main menu, choose File New Project to open the New Project
dialog box, which gives you a list of project type wizards to choose from. Expand the
Android option and click Android Project, as shown in Figure 3–1.
3
CHAPTER 3: Your First Android Project
24
Figure 3–1. Selecting a wizard in the Eclipse New Project dialog box
Click Next to advance to the first page of the New Android Project wizard, shown in
Figure 3–2.
CHAPTER 3: Your First Android Project
25
Figure 3–2. Eclipse New Android Project wizard, ready to fill in
Fill in the following and leave the default settings otherwise (the completed example for
this project is shown in Figure 3–3):
Project name: The name of the project (e.g., Now)
Build Target: The Android SDK you wish to compile against (e.g.,
Google APIs for Android 2.3.3)
Application name: The display name of your application, which will be
used for the caption under your icon in the launcher (e.g., Now)
Package name: The name of the Java package in which this project
belongs (e.g., com.commonsware.android.skeleton)
Create Activity: The name of the initial activity to create (e.g., Now)
CHAPTER 3: Your First Android Project
26
Figure 3–3. Eclipse New Android Project wizard, completed
At this point, click Finish to create your Eclipse project.
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 creates an application skeleton for you, complete with everything you need to build
your first Android application: Java source code, build instructions, and so forth.
CHAPTER 3: Your First Android Project
27
However, you’ll probably need to customize this somewhat. Here are what those
command-line switches mean:
--target: Indicates which 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
Android SDK and AVD Manager. You can find out which 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: 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 preceding command, a Skeleton/Now/ directory will be
created (or used if it exists) under the current working directory, and
the project files will be stored there.
--activity: Indicates the Java class name of your first activity for this
project. Do not include a package name, and make sure the name
meets Java class-naming conventions.
--package: Indicates the Java package in which your first activity will
be located. This package name also uniquely identifies your project on
any device on which you install it, and it must be unique on the
Android Market if you plan on distributing your application there.
Hence, typically, you should 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.
For your development machine, you need to pick a suitable target, and you may wish to
change the path. You can ignore the activity and package 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 you could build and run it,
whether on the Android emulator or on your Android device. Once again, the process
differs somewhat depending on whether you are using Eclipse or the command line.
Eclipse
With your project selected on the Package Explorer panel of Eclipse, click the green play
button in the Eclipse toolbar to run your project. The first time you do this, you 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 dialog box, choose Android Application, as shown in Figure 3–4.
收藏
分享
暂无回复
Author