Date post: | 13-May-2015 |
Category: |
Documents |
Upload: | attaporn-ninsuwan |
View: | 471 times |
Download: | 22 times |
Mobile Application Development
Dejvuth Suwimonteerabuth
Why mobile application development?
Worldwide mobile device sales to end users totaled 1.55 billionunits in 2011, a 11 percent increase from 2010 [IDC]
Sales for the first quarter of 2012 [IDC]:
Phones get “smarter”
Around 26% of worldwide sales in 2011 are smartphones, andestimated to reach 1 billion (47%) in 2015 [Gartner]
In U.S., 49.7% have smartphones, the trend is accelerating [Nielsen]
Smartphones aren’t smart without apps
More than 600,000 apps available [Business Insider]
Apps can make a lot of money
The mobile app market will reach $15 billion by 2013[Research2guidance]
Mobile applications are not ported desktop apps!
Factors that need to consider when working on a mobile app:Memory
Limited, and much of it is already allocatedApp speed
Usage patterns of mobile app are differentApps need to load and work quickly
Internet accessNetwork is not always available and typically slow
DisplaySmaller display
User inputButtons, touch screen
A bit of history and outlook
Brief history of mobile devices
PDA (Personal Digital Assistant)
PDA Phone
PDA + mobile phone→ PDA phone
Smartphones
Now PDA phones are called smartphones, offering manycomputer-like functionalities
Mobile applications
Applications for handheld devices such as PDA, smartphones
Development environment:
Wars on smartphone platform (2010) [Canalys]
Wars on smartphone platform (2012) [Gartner, IDC]
Wars on smartphone platform [Nielsen]
Apple vs. Google
Battle continues, arguments varied . . .
. . . depending on who you ask
A look into history: compare with Mac/PC battlesSimilar (many PC manufacturers, one Apple)Different (Microsoft sells Windows, Google gives awayAndroid)
Apple still dominates the market, but . . .
Another look at recent trendsIn April 2011, Android added 28,000 new apps, Apple 11,000apps [Research2guidance]
This course
This course
Application development for the Android platform
Introduction to iOS
Emphasis on basics to make the contents robust to changes.
Theories behind mobile communication
Prerequisite: strong Java programming skills
Important: Things change and not everything can be covered inthis course. Self-learning skill is necessary.
Android phone is not required
Topics
Java refresher
Key concepts of Android
Designing the user interface
2D graphics
Multimedia
Local data storage
Network access
Embedded database
3D graphics in OpenGL
Multi-touch
Widget
Schedule
On
10 Jun, 24 Jun, 8 Jul, 22 Jul, 19 Aug, 2 Sep, 16 Sep, 30 Sep
Lecture: 08:30–12:00
Lab: 13:00–17:00
Don’t come to class late!
Grading
Midterm exam 25%
Final exam 25%
Project 25%
Lab 15%
Attendance & Participation 10%
Below 50% is fail, above 80% is A
The rests are proportional
Project
At the end of the course, each of you must program anapplication on Android
You can program anything you want (but use your creativity!)
Due date: 30 September
Each of you must give a presentation on that day
Make sure your program is fully tested (non-functionalprograms are worse than simple but functional programs)!
Write down a documentation of what your program does
Marks are given based on creativity, complexity,documentations, and the presentation
Literature
The slides will be updated during the course of the lecture
References:“Hello, Android – Introducing Google’s MobileDevelopment Platform”, Ed Burnette, 3rd Edition (2010).http://developer.android.com
Any Java and Android books on the market
Java refresher
Why refresh?
Android applications are written in Java
Without fully understanding Java, you will not be able to writeany Android applications
Important: Take your time with Java, make sure you understandits concepts
We will use the slides Java Refresher Course fromAndrea Camesi, EPFL
Key Concepts
What is Android?
An open source software stack that includesOperating system: Linux kernel, provides low levelinterface with hardware, memory management, andprocess controlMiddleware: A run time to execute Android applications,including Dalvik virtual machine and core librariesKey mobile apps: Email, SMS, PIM, web browser, etcAPI libraries for writing mobile app such as SQLite,WebKit, and OpenGL ES
Open-source development platform for creating mobile apps
Android history
Android Inc. founded in 2003. Google acquired Android Inc.in 2005
Open Handset Alliance established on 5 November 2007Led by Google with 34 members (now 80 firms)Android is first announced on that day
Code name based on adessert item, inalphabetical order:1.5 Cupcake, 1.6 Donut,2.0/2.1 Eclair, 2.2 Froyo,2.3 Gingerbread,3.0/3.1 Honeycomb, and4.0 Ice Cream Sandwich
Android SDK features
No licensing, distributions, or development frees or releaseapproval processes
GSM, EDGE, and 3G networks for telephony and data transfer
Full multimedia hardware control
APIs for using sensor hardware including accelerometer andthe compass.
APIs for location based services
Inter-process communication
Shared data storage
Background applications and processes
Home screen widgets, Live Folders
HTML5 WebKit-based web browser
And many more . . .
Android SDK
The Android SDK includesThe Android APIs: the core of the SDKDevelopment tools: for compiling and debuggingThe Android Virtual Device (AVD) Manager and EmulatorDocumentationsSample code
There is no dedicated IDE for Android
However, Android has a special plugin for Eclipse, called ADTPlugin, for creating Android projects
ADT Plugin tightly integrates Eclipse with the Android Emulatorand debugging tools
Android architecture
Android architecture
Linux kernel
Android is built on top of a solid and proven foundation: theLinux kernel
Created by Linus Torvalds in 1991
Linux can be found today in everything from wristwatches tosupercomputer
It provides the hardware abstraction layer for Android as well asmemory management, process management, networking, andother operating system services
Android phone user will never see Linux, and your programswill not make Linux calls directly
Native libraries
Next layer above the kernel, written in C or C++
Compiled for the particular hardware architecture used by thephone, and preinstalled by the phone vendor
Important libraries include:Surface Manager: a compositing window manager2D and 3D graphicsMedia codecs for recording and playing variety of formatsincluding AAC, AVC (H.264), H.263, MP3, and MPEG-4SQLite database for storing persistent dataWebKit: a browser engine for fast display of HTML content
Libraries are not applications by themselves. They are only tobe called by higher-level layers.
Android runtime
Another layer on top of the kernel.
Android runtime includes the Dalvik virtual machine (VM) andthe core Java libraries.
Dalvik VM is Google’s implementation of Java, optimized formobile devices
Differ from traditional Java VM:Dalvik VM runs .dex files, converted at compile time fromstandard .class and .jar files. Reason: .dex files aremore compact.Android’s core Java libraries are different from both theJava Standard Edition (Java SE) libraries and the JavaMobile Edition (Java ME) libraries
Application framework
Sitting above the native libraries and runtime
Provides high-level building blocks for creating applications
Comes pre-installed with Android, can be extend if needed
Important parts are:Activity manager controls the life cycles of applications anduser navigationContent providers encapsulate data that needs to beshared between applications, such as contactsResource manager provides access to non-code resourcessuch as localized strings, graphics, and layout filesLocation manager provides location informationNotification manager presents messages to users
Applications and widgets
The highest layer. They are what users see.
Applications are programs that take over the whole screen andinteract with users
Widgets operate only in a small rectangle of the Home screenapplication
Standard system applications: phone dialer, email, contacts,web browser, Android markets
The most part of this course will cover application development.Widgets development is at the end of the course.
Life cycle
One foreground application at a time
On PC, many applications running and visible at once indifferent windows. One of the windows has keyboard focus, butotherwise all the programs are equal.
In Android, one foreground application, typically takes over thewhole screen except for the status line.
Users first see the Home application when turning on theirphones
Application stack
When the user runs an application, Android starts it and bringsit to the foreground.
From that application, the user might invoke anotherapplication, or another screen in the same application, and thenanother and another.
All these programs and screens are recorded on the applicationstack by the system’s Activity Manager.
At any time, the user can press the Back button to the previousscreen on the stack.
Process 6= application
Internally, each user interface screen is represented by anActivity class
Each activity has its own life cycle
An application is one or more activities plus a Linux process tocontain them
However, the activity life cycle is not tied to the process lifecycle
Processes are just disposable containers for activities, so anapplication can be “alive” even if its process has been killed!
Life cycle
During its lifetime, each activity of an Android program can bein one of the following states:
Life cycle (cont.)
Developers do not have control over what states their programsare in
The system manages changes of states and notify developerswhen they are about to change through the onXX() methodcalls
We override these methods in the Activity class, andAndroid will call them at the appropriate time:
onCreate(Bundle): This is called when the activity firststarts up.You can use it to perform one-time initialization such ascreating the user interface. onCreate() takes oneparameter that is either null or some state informationpreviously saved by the onSaveInstanceState()method.
Life cycle (cont.)
onStart(): This indicates the activity is about to bedisplayed to the useronResume(): This is called when your activity can startinteracting with the user. This is a good place to startanimations and music.onPause(): This runs when the activity is about to go intothe background, usually because another activity has beenlaunched in front of it. This is where you should save yourprogram’s persistent state, such as a database recordbeing edited.onStop(): This is called when your activity is no longervisible to the user and it won’t be needed for a while. Ifmemory is tight, onStop() may never be called (thesystem may simply terminate your process).
Life cycle (cont.)
onRestart(): Indicates that your activity is beingredisplayed to the user from a stopped stateonDestroy(): This is called right before your activity isdestroyed. If memory is tight, onDestroy() may never becalled (the system may simply terminate your process).onSaveInstanceState(Bundle): Android will call thismethod to allow the activity to save per-instance state,such as a cursor position within a text field. Usually youwon’t need to override it because the defaultimplementation saves the state for all your user interfacecontrols automatically.onRestoreInstanceState(Bundle): This is calledwhen the activity is being reinitialized from a statepreviously saved by the onSaveInstanceState()method. The default implementation restores the state ofyour user interface.
Caveat
Activities that are not running in the foreground may bestopped, or the Linux process that houses them may be killedat any time in order to make room for new activities
So, design your app with this in mind!
In some cases, onPause() may be the last method called inyour activity, so that’s where you should save any data you wantto keep around for next time.
Building blocks
Activities
An activity is a user interface screen
Applications can define one or more activities to handledifferent phases of the program.
As discussed earlier, each activity is responsible for saving itsown state so that it can be restored later as part of theapplication life cycle
Intents
An intent is a mechanism for describing a specific action, suchas “pick a photo”, “phone home”, or “open the pod bay doors”
Just about everything goes through intents, many componentscan be replaced or reused
For example, there is an intent for “send an email”. Your appcan invoke that intent to send emails.
Or you can write a new email application, and register anactivity to handle that intent and replace the standard mailprogram
Next time somebody tries to send an email, they’ll get theoption to use your program instead of the standard one
Services
A service is a task that runs in the background without theuser’s direct interaction
For example, consider a music player. The music may bestarted by an activity, but you want it to keep playing even whenthe user has moved on to a different program.
So, the code that does the actual playing should be in aservice.
Later, another activity may bind to that service and tell it toswitch tracks or stop playing.
Android comes with many services built in, along withconvenient APIs to access them.
Content providers
A content provider is a set of data wrapped up in a custom APIto read and write it
This is the best way to share global data between applications.
For example, Google provides a content provider for contacts.All the information there—names, addresses, phone numbers,and so forth—can be shared by any application that wants touse it.
Resources
A resource is a localized text string, bitmap, or other smallpiece of noncode information that your program needs.
Useful for internationalization and for supporting multiple devicetypes
Inside your project, resources are stored in the res directory.Its subfolders determine the content types, e.g. PNG and JPGin res/drawable and XMLs for screen layouts inres/layout
At build time all resources get compiled into the application.The compiler generates a class named R that containsidentifiers that can be used to reference those resources in theprogram
The AndroidManifest.xml file
Every application must have an AndroidManifest.xml file(with precisely that name) in its root directory.
The manifest presents essential information about theapplication to the Android system
Among other things, the manifestnames the Java package for the applicationdescribes the components of the application—theactivities, services, broadcast receivers, and contentproviders that the application is composed ofdetermines which processes will host applicationcomponentsdeclares which permissions the application must havedeclares the minimum level of the Android API that theapplication requires.
Security
As mentioned earlier, every application runs in its own Linuxprocess
The hardware forbids one process from accessing anotherprocess’s memory
Furthermore, every application is assigned a specific user ID.Any files it creates cannot be read or written by otherapplications.
Access to certain critical operations are restricted. To usethem, permissions must be specifically asked in a file namedAndroidManifest.xml
When installing, the Package Manager either grants or doesn’tgrant the permissions based on certificates and, if necessary,user prompts
Permissions in AndroidManifest.xml
Common permissions:INTERNET: Access the InternetREAD_CONTACTS: Read the user’s contacts dataWRITE_CONTACTS: Write the user’s contacts dataRECEIVE_SMS: Monitor incoming SMS messagesACCESS_COARSE_LOCATION: Use a coarse locationprovider such as cell towers or wifiACCESS_FINE_LOCATION: Use a more accurate locationprovider such as GPS
E.g., add the following tag to monitor incoming SMS messages:
<uses-permission android:name="android.permission.RECEIVE_SMS" />
Designing the User Interface
Designing the User Interface
In this section: how to design user interfaces
We will learn by going through examples based on Sudoku
Sudoku
You have a grid of 81 tiles (9× 9)
When the game starts, some numbers are already filled in
You try to fill in the rest so that each column, each row, andeach of the 3× 3 sub-grids contains the numbers 1 through 9only once
Procedural vs. declarative UI design
Procedural design is done in code, e.g. Java Swing where codemust be written to create and manipulate UI objects such asJFrame and JButton
Declarative design does not involve code, e.g. HTML where youdescribe what you want to see, not how you want to do it
Android can handle both, either in Java or XML
It is recommended, however, to use XML as much as possibleas it is often shorter and easier to understand, and less likely tochange
R.java
By default, the main (declarative) UI of your program is kept inmain.xml in the res/layout directory
The file can be referred in the code by using the resourceidentifier R.layout.main
Eclipse plug-in automatically generates the class R.java fromfiles in the res directory
Values in R.java are not objects, but simply handles that referto the real data
public static final class layout {public static final int main=0x7f030000;
}
Layout resource
Define the architecture for the UI in an Activity or a componentof a UI
Start with
<?xml version="1.0" encoding="utf-8"?>
Technically, a layout resource contains ViewGroup and View
For example,
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"android:orientation="vertical"android:layout_width="fill_parent"android:layout_height="fill_parent" ><TextView
android:id="@+id/nameTextbox"... />
<!- ... -></LinearLayout>
ViewGroup
A container for View elements
FrameLayout arranges its children so they all start at the topleft of the screen. This is used for tabbed views and imageswitchers.
LinearLayout arranges its children in a single column or row.This is the most common layout you will use.
RelativeLayout arranges its children in relation to eachother or to the parent
TableLayout arranges its children in rows and columns,similar to an HTML table
View
An individual UI component, generally referred to as a “widget”,e.g. TextView, Button, CheckBox
Use @+id/name to define an ID
In Java, use findViewById(R.id.nameTextbox) to referto the TextView nameTextBox
Reference to layout resource:http://developer.android.com/guide/topics/resources/layout-resource.html
Don’t forget to check out the reference
Some parameters to all layouts
xmlns:android="http://schemas.android.com/apk/res/android"
Defines the XML namespace for Android. You should definethis once, on the first XML tag in the file.
android:layout_width="fill_parent",android:layout_height="fill_parent"
Takes up the entire width and height of the parent (in this case,the window)
android:layout_width="wrap_content",android:layout_height="wrap_content"
Just big enough to enclose its content
strings.xml
Do not hard-code strings. Instead, define them inres/values/strings.xml.
For example,
<?xml version="1.0" encoding="utf-8"?><resources>
<string name="app_name">Sudoku</string><string name="main_title">Android Sudoku</string><!- ... ->
</resources>
Use @string/resid to refer the the string resid
app_name, used in AndroidManifest.xml, is the app name
main_title can be used in main.xml, e.g.
<TextViewandroid:layout_width="fill_parent"android:layout_height="wrap_content"android:text="@string/main_title" />
colors.xml
Define colors in res/values/colors.xml
For example,
<?xml version="1.0" encoding="utf-8"?><resources>
<color name="background">#3500ffff</color></resources>
Colors are defined in Alpha-Red-Green-Blue format
Use @color/resid to refer to the color resid, e.g.
android:background="@color/background"
Activity (revisited)
An activity is a single, focused thing that the user can do
The Activity class takes care of creating a window.
Subclasses of Activity should implement:onCreate(Bundle) initialize your activity.Call setContentView(int) with a layout resource todefine UI.Use findViewById(int) to retrieve the widgets in thatUI that you need to interact with programmatically.onPause() deals with the user leaving your activity. Anychanges made by the user should be committed at thispoint.
Intent (revisited)
An intent is an abstract description of an operation to beperformed.
It can be used with startActivity(Intent) to launch anActivity
Declare all activities you start in AndroidManifest.xml, e.g.
<activity android:name=".About"android:label="@string/about_title" >
</activity>
Think of an intent as a glue between activities, basically apassive data structure holding an abstract description of anaction to be performed.
Styles
A style is a collection of properties that specify the look andformat for a View or window.
A style can specify properties such as height, padding, fontcolor, font size, background color, etc.
Similar to cascading stylesheets (CSS)
Define a style using XML in res/values/
<?xml version="1.0" encoding="utf-8"?><resources>
<style name="CodeFont"parent="@android:style/TextAppearance.Medium">
<item name="android:layout_width">fill_parent</item><item name="android:layout_height">wrap_content</item><item name="android:textColor">#00FF00</item><item name="android:typeface">monospace</item>
</style></resources>
Styles and Themes
Apply a style to a View
<TextViewstyle="@style/CodeFont"android:text="@string/hello" />
A theme is a style applied to an entire Activity orapplication. When applied, every View in the Activity orapplication will apply each style property that it supports
Apply a theme to an Activity
<activity android:theme="@android:style/Theme.Dialog">
The @android: prefix means this is a reference to a resourcedefined by Android, not one that is defined in your program
Options menu
Define a menu using XML in res/menu/
<?xml version="1.0" encoding="utf-8"?><menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/settings"android:title="@string/settings_label"android:alphabeticShortcut="@string/settings_shortcut" />
</menu>
Override Activity.onCreateOptionsMenu(Menu)
@Overridepublic boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);MenuInflater inflater = getMenuInflater();inflater.inflate(R.menu.menu, menu);return true;
}
getMenuInflater() is used to read the menu definition frommain.xml and turns it into a real view
Options menu and context menu
When the user selects any menu item,onOptionsItemSelected() will be called
@Overridepublic boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {case R.id.settings:
startActivity(new Intent(this, Prefs.class));return true;
// More items go here (if any) ...}return false;
}
Apart from options menu, a context menu can be used toprovide the user access to actions that pertain to a specific item
In this case, use onCreateContextMenu andonContextItemSelected instead
Preferences
Define a preference screen using XML in res/xml/
<?xml version="1.0" encoding="utf-8"?><PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android" ><CheckBoxPreference
android:key="music"android:title="@string/music_title"android:summary="@string/music_summary"android:defaultValue="true" />
<!- ... -></PreferenceScreen>
Subclass PreferenceActivity, and override onCreate tocall addPreferencesFromResource
public class Prefs extends PreferenceActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);addPreferencesFromResource(R.xml.settings);
}}
AlertDialog
A Dialog that can display an array of things
new AlertDialog.Builder(this).setTitle(R.string.new_game_title).setItems(R.array.difficulty,
new DialogInterface.OnClickListener() {public void onClick(DialogInterface dialoginterface,
int i) {startGame(i);
}})
.show();
An array can be defined using XML in res/values
<?xml version="1.0" encoding="utf-8"?><resources>
<array name="difficulty"><item>@string/easy_label</item><item>@string/medium_label</item><item>@string/hard_label</item>
</array></resources>
Debugging
The Log class provides several static methods to printmessages of various severity levels to the Android system log:
Log.e(): ErrorsLog.w(): WarningsLog.i(): InformationLog.d(): DebuggingLog.v(): VerboseLog.wtf(): What a Terrible Failure
Open LogCat to view the logs
In addition, the Eclipse debugger can be used to setbreakpoints, single step, and view the state of your program.
Add android:debuggable=“true” inAndroidManifest.xml
Graphics
Graphics in Android
In this section: how to make graphics in Android
Good graphics is very important these days
Android has very powerful graphics libraries: both 2D and 3D
We cover 2D graphics here, and apply it to the Sudoku example
3D graphics will be covered later
The basics
Native 2D graphics library: android.graphics package
Let’s start with Color, Paint, Canvas, Path, Drawableclasses
Color
Colors are represented with four numbers: alpha, red, green,and blue (ARGB)
Each has 8 bits or 256 possible values
Alpha is a measure of transparency: 0 is completelytransparent.Example:int b = Color.BLUE; // solid blueint c = Color.argb(127, 255, 0, 255); // translucent purple
Define your colors in an XML resource file<?xml version="1.0" encoding="utf-8"?><resources>
<color name="mycolor">#1fff00ff</color></resources>
In Java, we can reference colors by their namescolor = getResources().getColor(R.color.mycolor);
Paint
Hold the style and color information about how to drawgeometries, text and bitmaps
Examples:setColor(int): sets the paint’s colorsetTextSize(float): sets the paint’s text sizesetStyle(Paint.Style): sets the paint’s style, usedfor controlling how primitives’ geometries are interpreted(filled and/or stroked)
Path
Hold a set of vector-drawing commands such as lines,rectangles, and curves
Example of a circle at position x = 150, y = 150, with radius of100 pixels.
circle = new Path();circle.addCircle(150, 150, 100, Direction.CW);
Canvas
Represent a surface to draw upon
Initially, it has no contents. Use its methods to draw lines,rectangles, circles, or other arbitrary graphics.
Activity hosts View, which in turn hosts Canvas
Override the method View.onDraw(Canvas) to draw yourcontents on the canvas
Example:
private static final String QUOTE = "Now is the time for all "+ "good men to come to the aid of their country.";
canvas.drawPath(circle, cPaint);canvas.drawTextOnPath(QUOTE, circle, 0, 20, tPaint);
Drawable
An abstract class for “something that can be drawn”
Drawables can take a variety of forms:Bitmap: the simplest drawable, a PNG or JPEG imageNine Patch: a stretchable PNG imageShape: vector-drawing commands, based on Path
Layers: a container for child drawables, on top of eachotherStates: a container that shows one of its child drawablesbased on its state (a bit mask)Levels: a container that shows one of its child drawablesbased on its level (a range of integers)Scale: a container for one child drawable that modifies itssize based on the current level
The book’s example
Adding graphics to Sudoku
What have been done so far?
Now, draw the board
Next, draw the numbers
Draw the hints
Draw the selection
Multimedia
Multimedia
Android provides support for encoding and decoding a varietyof common media types
Easy to integrate audio, video, and images into applications
Use the package: android.media
In particular, the MediaPlayer class
An object of this class can fetch, decode, and play both audioand video with minimal setup
Support several media sources:Local resourcesInternal URIsExternal URLs (streaming)
Play audioPlay from a local raw resource (in res/raw)
MediaPlayer mp = MediaPlayer.create(context, R.raw.sound_file_1);mp.start();
Play from a URI, available locally in the system
Uri uri = ...; // initialize Uri hereMediaPlayer mp = new MediaPlayer();mp.setAudioStreamType(AudioManager.STREAM_MUSIC);mp.setDataSource(getApplicationContext(), uri);mp.prepare();mp.start();
Play from a remote URL via HTTP streaming
String url = ...; // your URL hereMediaPlayer mp = new MediaPlayer();mp.setAudioStreamType(AudioManager.STREAM_MUSIC);mp.setDataSource(url);mp.prepare(); // might take long! (for buffering, etc)mp.start();
Asynchronous preparation
prepare() can take a long time, because it might involvefetching and decoding media data
So, never call it from UI thread
Instead, use the convenient method prepareAsync(). Itspawns another thread to prepare MediaPlayer and notify themain thread when done.
Use MediaPlayer.OnPreparedListener for thenotification
MediaPlayer’s state diagram
Releasing the MediaPlayer
A MediaPlayer can consume valuable system resources
So, call release() to release system resources allocated to it
For example, release it in Activity.onStop()
mp.release();mp = null;
Using a Service with MediaPlayer
Use Service to play media in the background. So, It willcontinue playing even the user is interacting with otherapplications.
Use wake locks to guarantee that the service keeps playingeven if the phone is idle
The following will keep the CPU to remain wakemp = new MediaPlayer();mp.setWakeMode(getApplicationContext(),
PowerManager.PARTIAL_WAKE_LOCK);
Acquire WifiLock, if streaming media over the network:WifiLock wifiLock =
((WifiManager) getSystemService(Context.WIFI_SERVICE)).createWifiLock(WifiManager.WIFI_MODE_FULL, "mylock");
wifiLock.acquire();
To release:wifilock.release();
Data Storage
Data Storage
Android provides several options to save persistent applicationdata
Shared preferences: store private primitive data inkey-value pairsInternal storage: store private data on the device memoryExternal storage: store public data on the shared externalstorageSQLite database: store structured data in a privatedatabaseNetwork connection: store data on the web with your ownnetwork server
We will cover the first three today
Using shared preferences
The SharedPreferences class provides a generalframework for saving and retrieving persistent key-value pairsof primitive data types
Use getSharedPreferences() to get an object
To write values:Call edit() to get a SharedPreferences.Editor
Adds values with methods such as putBoolean() andputString()
Commit the new values with commit()
To read values, use methods such as getBoolean() andgetString()
Example of shared preferences
public class Calc extends Activity {public static final String PREFS_NAME = "MyPrefsFile";
@Overrideprotected void onCreate(Bundle state){super.onCreate(state);...
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);boolean silent = settings.getBoolean("silentMode", false);setSilent(silent);
}
@Overrideprotected void onStop(){super.onStop();
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);SharedPreferences.Editor editor = settings.edit();editor.putBoolean("silentMode", mSilentMode);
editor.commit();}
}
Using the internal storage
You can save files directly on the device’s internal storage
By default, files saved to the internal storage are private to yourapplication
When the application is uninstalled, these files are removed.
To create and write a private file:Call openFileOutput() with the name of the file and theoperating modeWrite with write()
Close with stream with close()
To read a file:Call openFileInput() with the name of the file. Itreturns FileInputStreamRead bytes with read ()
Close with stream with close()
Example of internal storageExample:
String FILENAME = "hello_file";String string = "hello world!";
FileOutputStream fos = openFileOutput(FILENAME,Context.MODE_PRIVATE);
fos.write(string.getBytes());fos.close();
Some useful methods:getFilesDir() – Gets the absolute path to the directorywhere internal files are savedgetDir() – Creates (or opens an existing) directorywithin your internal storage spacedeleteFile() – Deletes a file saved on the internalstoragefileList() – Returns an array of files currently saved byyour application
Using the external storage
Every Android device supports a shared “external storage” thatyou can use to save files
This can be a removable storage media (such as an SD card)or an internal (non-removable) storage
Files saved to the external storage are world-readable and canbe modified by the user when they enable USB mass storage totransfer files on a computer
Some useful methods
Before doing any work with external storage, callgetExternalStorageState() to check whether the mediais available
Use getExternalFilesDir() to open a directory. Thisdirectory is local to the app and will be deleted when the app isuninstalled.
Use getExternalStoragePublicDirectory() to open adirectory. This directory is shared and will NOT be deletedwhen the app is uninstalled.
In both cases, use e.g. DIRECTORY_MUSIC,DIRECTORY_RINGTONES, or DIRECTORY_PICTURES tospecify the type of subdirectory
The Web
The Web
In this chapter: connect your app to the web
Two simple approaches:Open an external web browser from your appEmbed a browser into your app
Also include:How to connect JavaScript and Android’s Java codeWeb services
Browsing by Intent
The simplest thing you can do: open a browser from your app
All it takes are three lines of code!
private void openBrowser() {Uri uri = Uri.parse(urlText.getText().toString());Intent intent = new Intent(Intent.ACTION_VIEW, uri);startActivity(intent);
}
This codepauses your app, andstarts the Browser activity with its own view
Remember the app stack: when the Back key is pressed, thebrowser will go away, and your app will continue
Web with a View
Android provides a wrapper around the WebKit browser enginecalled WebView
WebView works like any other view, except that it has a fewextra methods specific to the browser
private void openBrowser() {webView.getSettings().setJavaScriptEnabled(true);webView.loadUrl(urlText.getText().toString());
}
The loadUrl() method causes the browser engine to beginloading and display a web page. It does not wait for the loadingto finish and returns immediately.
To access the Internet, add this line toAndroidManifest.xml
<uses-permission android:name="android.permission.INTERNET" />
Some WebView’s useful methods
addJavascriptInterface(): Allows a Java object to beaccessed from JavaScript
createSnapshot(): Creates a screenshot of the currentpage
getSettings(): Returns a WebSettings object used tocontrol the settings
loadData(): Loads the given string data into the browser
loadDataWithBaseURL(): Loads the given data using abase URL
loadUrl(): Loads a web page from the given URL
Some WebView’s useful methods (cont.)
setDownloadListener(): Registers callbacks for downloadevents, such as when the user downloads a .zip or .apk file
setWebChromeClient(): Registers callbacks for events thatneed to be done outside the WebView rectangle, such asupdating the title or progress bar or opening a JavaScript dialogbox
setWebViewClient(): Lets the application set hooks in thebrowser to intercept events such as resource loads, keypresses, and authorization requests
stopLoading(): Stops the current page from loading
Calling JavaScript from Java
Use the WebView’s loadUrl() method, passing it a URL ofthe form javascript:code-to-execute
Example: define function callJS() in assets/index.html
<script language="JavaScript">function callJS(arg) {document.getElementById(’replaceme’).innerHTML = arg;
}</script>...<p id="replaceme"></p>
In Java, first load the index.html
webView.loadUrl("file:///android_asset/index.html");
The function callJS() can be called by
webView.loadUrl("javascript:callJS(’Hello from Android’)");
Calling Java from JavaScript
Use the WebView’s addJavascriptInterface() method todefine objects that JavaScript code can access
Example: define a class to be exposed to JavaScript
private class AndroidBridge {public void callAndroid(final String arg) {handler.post(new Runnable() {public void run() {textView.setText(arg);
}});
}}
Then, register it to JavaScript
webView.addJavascriptInterface(new AndroidBridge(), "android");
Calling Java from JavaScript (cont.)
For alerts or progress updates, use setWebChromeClient()
webView.setWebChromeClient(new WebChromeClient() {@Overridepublic boolean onJsAlert(final WebView view,
final String url, final String message, JsResult result) {Toast.makeText(LocalBrowser.this, message, 3000).show();result.confirm();return true; // I handled it
}});
Calls from JavaScript
<a href="#"onclick="window.alert(’Alert from JavaScript’)">Display JavaScript alert</a>
<a href="#"onclick="window.android.callAndroid(’Hello from Browser’)">Call Android from JavaScript</a>
Using web services
Android fully supports java.net.HttpURLConnection formaking requests to a HTTP server
Example:
String q = URLEncoder.encode(original, "UTF-8" );URL url = new URL(
"http://ajax.googleapis.com/ajax/services/language/translate"+ "?v=1.0" + "&q=" + q + "&langpair=" + from+ "%7C" + to);
// Creates a connection and set parameterscon = (HttpURLConnection) url.openConnection();con.setReadTimeout(10000 /* milliseconds */);con.setConnectTimeout(15000 /* milliseconds */);con.setRequestMethod("GET" );con.addRequestProperty("Referer" ,
"http://www.pragprog.com/titles/eband3/hello-android" );con.setDoInput(true);
// Starts the querycon.connect();
Using web services (cont.)
However, such calls must be made asynchronously to makesure that your app remains responsive
Trick: use the java.util.concurrent package
Use ExecutorService to manage threadsSubmit an instance of Runnable or CallableAn instance of the Future class is returned
A Future instance represents the as-yet-unknown future valuethat will be returned by your task (if any)
An example: Google Translation API
GPS
GPS
The Global Positioning System (GPS) is a constellation of 27Earth-orbiting satellites (24 in operation + 3 extras)
The US military developed it as a military navigation system,later opened up for everybody
Each satellite circles the globe at about 19,300 km, making twocomplete rotations everyday
The orbits: at any time, anywhere on Earth, there are at leastfour satellites visible in the sky
GPS receivers locate at least four satellites, figure the distanceto each, and use this information to deduce its own location.
This operation is based on a simple math principle calledtrilateration
2D Trilateration
To simplify explanations: let’s start with two-dimensionaltrilateration
Imagine that you are totally lost. You find a friendly local andask, “Where am I?”. He says, “You are 700 km from Bangkok”
You could be anywhere on a circle around Bangkok that has aradius of 700 km:
Bangkok
Second circle
You ask somebody else, and she says, “You are 640 km fromKuala Lumpur”
Combining with the previous information, you know that youmust be at one of the two intersection points
Bangkok
KL
Third circle
If a third person tells you that you are 1000 km from Yangon,you can eliminate one of the possibilities, and know exactlywhere you are (can you guess where?)
Bangkok
KL
Yangon
3D Trilateration
Generalize the concept to 3D: spheres instead of circles
Imagine you are X miles from satellite A in the sky. You couldbe anywhere on the surface of an imaginary sphere with X-kmradius.
Second sphere
If you also know you are Y miles from satellite B, you canoverlap the first sphere with this sphere
Two spheres overlap in a circle
Third sphere
The third satellite will give a third sphere, which intersects thecircle at two points
Fourth sphere
The Earth can act as a fourth sphere, i.e. only one of the twopossible points is on the surface of the planet
However, receivers generally look to four or more satellites toimprove accuracy and provide precise altitude information
To make the calculation, GPS receiver needs to know twothings:
The location of at least three satellitesThe distance between you and each of the satellites
Idea: determine the time delays when signals travel fromsatellites to the receiver
For this to work, clocks on the satellites and the receiver mustbe synchronized to nanoseconds
Quite a few techniques involved. Anyway, details are beyondthe scope of this lecture
In this course: how to use GPS in your app!
Finding locations
To gain access to location information, both from GPS andcoarse-grained location provider such as cell towertriangulation, add the following lines toAndroidManifest.xml
<uses-permissionandroid:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permissionandroid:name="android.permission.ACCESS_FINE_LOCATION" />
Get a LocationManager from your Context
LocationManager mgr= (LocationManager) getSystemService(LOCATION_SERVICE);
Select the best location provider. A Criteria object can beused to select a location provider based on e.g. power oraccuracy (in this case, no restrictions).
Criteria criteria = new Criteria();String best = mgr.getBestProvider(criteria, true);
Finding locations (cont)
Query the last known (possibly outdated) location
Location location = mgr.getLastKnownLocation(best);
Edit onResume and onPause to have Android updateslocations only when your app is in the foreground (assume thatyour class implements LocationListener)
@Overrideprotected void onResume() {
super.onResume();mgr.requestLocationUpdates(best, 15000, 1, this);
}
@Overrideprotected void onPause() {
super.onPause();mgr.removeUpdates(this);
}
Sensors
Sensors
Android SDK supports many different types of sensor devicesTYPE_ACCELEROMETER: Measures acceleration in the x-,y-, and z-axesTYPE_LIGHT: Tells you how bright your surrounding areaisTYPE_MAGNETIC_FIELD: Returns magnetic attraction inthe x-, y-, and z-axesTYPE_ORIENTATION: Measures the yaw, pitch, and roll ofthe deviceTYPE_PRESSURE: Senses the current atmosphericpressureTYPE_PROXIMITY: Provides the distance between thesensor and some objectTYPE_TEMPERATURE: Measures the temperature of thesurrounding area
SensorManager
Similar to LocationManager, here we use SensorManager
SensorManager mgr= (SensorManager) getSystemService(SENSOR_SERVICE)
Then, call registerListener() in onResume() andunregisterListener() in onPause() to start/stop gettingupdates
The sensor service will call onSensorChanged() every time avalue changes. It should look like this:
public void onSensorChanged(SensorEvent event) {for (int i = 0; i < event.values.length; i++) {// ...
}}
Sensor readings
All sensors return an array of floating-point values. The size ofthe array depends on the particular sensor.
Turning sensor readings into meaningful information can bevery tricky
Do experiments on what you want!
Most of time it is not possible to test sensor readings on theemulator. If your application relies heavily on one of thesesensors, you will need to a real device to test
SQLite
SQLite
A tiny but powerful database engine, created by Dr. RichardHipp in 2000
Widely used, e.g. in Mozilla Firefox, Skype, PHP, Adobe AIR,Mac OS X, iPhone, and of course Android
Notable features:FreeSmall, less than 325KBRequire no setup, no server, no config file, noadministration
An SQLite database is just a file
Android stores it in /data/data/packagename/databases
SQL refresher
A Data Definition Language (DDL) statement to create a table
create table mytable (_id integer primary key autoincrement,name text,phone text );
Note column types in SQLite are not strict. So, it’s possible toe.g. store a string in an integer column.
Insert a record
insert into mytable values(null, ’Steven King’ , ’555-1212’ );
Query for a record
select * from mytable where(_id=3);
SQLiteOpenHelper
Subclass SQLiteOpenHelper to manage database creationand versionspublic class EventsData extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "events.db";private static final int DATABASE_VERSION = 1;
public EventsData(Context ctx) {super(ctx, DATABASE_NAME, null, DATABASE_VERSION);
}
@Overridepublic void onCreate(SQLiteDatabase db) {db.execSQL("CREATE TABLE " + TABLE_NAME + " (" + _ID+ " INTEGER PRIMARY KEY AUTOINCREMENT, " + TIME+ " INTEGER," + TITLE + " TEXT NOT NULL);" );
}
@Overridepublic void onUpgrade(SQLiteDatabase db, int oldVersion,
int newVersion) {db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);onCreate(db);
}}
Adding a row
Use getWritableDatabase() to get a read/write handle tothe events database, and then use insertOrThrow() to dothe actual INSERT
private void addEvents(String string) {SQLiteDatabase db = events.getWritableDatabase();ContentValues values = new ContentValues();values.put(TIME, System.currentTimeMillis());values.put(TITLE, string);db.insertOrThrow(TABLE_NAME, null, values);
}
Running a query
Use getReadableDatabase() to get a read-only handle tothe events database, and then use query() to do the actualSELECT
private static String[] FROM = _ID, TIME, TITLE, ;private static String ORDER_BY = TIME + " DESC" ;private Cursor getEvents() {
SQLiteDatabase db = events.getReadableDatabase();Cursor cursor = db.query(TABLE_NAME, FROM, null, null, null,
null, ORDER_BY);startManagingCursor(cursor);return cursor;
}
The method startManagingCursor() tells the activity totake care of managing the cursor’s life cycle based on theactivity’s life cycle. E.g., deactivate the cursor when the activityis paused, or close it when the activity is terminated
Display the query results
Use Cursor to iterate through all result rows
while (cursor.moveToNext()) {long id = cursor.getLong(0);long time = cursor.getLong(1);String title = cursor.getString(2);...
}
Alternatively, instead of using 0, 1, or 2 in getXXX(), usegetColumnIndexOrThrow() to get column index numbers
Data binding
Android provides a convenient way to display query results:
Create a layout for items, call it e.g. item.xml
Subclass ListActivity and use SimpleCursorAdapter
private static int[] TO = { R.id.rowid, R.id.time, R.id.title };...SimpleCursorAdapter adapter = new SimpleCursorAdapter(this,
R.layout.item, cursor, FROM, TO);setListAdapter(adapter);
Define your activity layout main.xml like this
<ListViewandroid:id="@android:id/list"... />
<TextViewandroid:id="@android:id/empty"... />
If the list has items, android:id/list will be displayed,otherwise android:id/empty will be displayed
Content provider
Recall that one application cannot access data own by anotherapplication
A way to share data is to use ContentProvider:
Processes register themselves to the system as providers ofcertain kinds of data. When that information is requested, theyare called by Android through a fixed API to query or modify thecontent
Content provider (cont)
Any piece of information managed by a ContentProvider isaddressed through a URI that looks like this:
content://authority/path/id
whereauthority is the name of the provider, usually the packagenamepath is a virtual directory within the providerid is the primary key of the requested record. Omit this torequest all records.
Android comes with several providers built in, includingcontent://browser
content://contacts
content://media
content://settings
Using ContentProvider
Example of a valid URI:
public static final String AUTHORITY = "org.example.events" ;public static final Uri CONTENT_URI = Uri.parse("content://"+ AUTHORITY + "/" + TABLE_NAME);
Adding a row
getContentResolver().insert(CONTENT_URI, values);
Running a query
Cursor cursor = managedQuery(CONTENT_URI, FROM, null,null, ORDER_BY);
Implement a ContentProvider
Refer to the lab!
Services
Services
A service is an application component that can performoperations in the background and does not provide a UI
Another application component can start a service. It willcontinue to run in the background, even if the user switches toanother application
Also, a component can bind to a service to interact with it andeven perform interprocess communication (IPC)
Examples: network transactions, play music, perform file I/O
Types of services
A service can take two forms:
Started when an application component call startService()Once started, a service can run indefinitely, even if thecomponent is destroyedUsually perform a single operation, does not return a resultExample: download or upload file over the networkWhen the operation is done, it should stop itself
Bound when an application component call bindService()Offer a client-server interface that allows components tointeract with the service, send requests, get results, do IPCRun as long as another component is bound to itMultiple components can bind to the service at once
Types of services (cont.)
A service can be of both types: it can be started to runindefinitely and also allow binding. Just implement bothonStartCommand() and onBind()
Just like an activity, a service started with an Intent
Caution: a service runs in the main thread of its hostingprocesses, it does not create its own thread and does not run ina separate process
Use a separate thread if your service can be slow
The basics
To create a service, subclass Service and override thefollowing callback methods:
onStartCommand(): the system calls this method whenanother component call startService(). The servicewill run indefinitely unless stopSelf() orstopService() is calledonBind(): the system calls this method when anothercomponent call bindService(). You must alwaysimplement this method (simply return null if binding is notallowed)onCreate(): the system calls this method when theservice is first created. Use it to perform one-time setup.onDestroy(): the system calls this method when theservice is being destroyed. Use it to clean up resources.
Declaring a service in the manifest
Add a <service> element as a child of the <application>element
<manifest ... >...<application ... ><service android:name=".ExampleService" />...
</application></manifest>
android:name is the only required attribute
To make a service private, set android:exported="false"
Reference:http://developer.android.com/guide/topics/manifest/service-element.html
IntentService
In most case, you can implement a service usingIntentService, a subclass of Service
It creates a worker thread to handle intents delivered toonStartCommand(), separate from your main thread
Provides to default implementation of onStartCommand() tosend one intent at a time to onHandleIntent()
Stops the service after all start requests have been handled, sono need to call stopSelf()
Provides default implementation of onBind() that returns null
All you need to do is implement onHandleIntent()
References
API:http://developer.android.com/reference/android/app/
Service.html
Fundamentals:http://developer.android.com/guide/topics/fundamentals/
services.html
A Very Brief Introduction to OpenGL
3D with OpenGL
Android supports high performance 3D graphics with the OpenGraphics Library (OpenGL), specifically, the OpenGL ES API
OpenGL is a cross-platform graphics API that specifies astandard software interface for 3D graphics processinghardware
OpenGL ES is a subset of OpenGL, designed for embeddedsystems
OpenGL ES 1.0 and 1.1 have been supported sinceAndroid 1.1
Beginning with Android 2.2, OpenGL ES 2.0 is also supported
GLSurfaceView
Two foundational classes:
GLSurfaceView: a View you can draw and manipulateobjects through API calls
GLSurfaceView.Renderer: an interface that definesmethods required for drawing graphics in GLSurfaceView.
You must implement this interface, and attach it toGLSurfaceView by using setRenderer().
GLSurfaceView.Renderer
To implement the GLSurfaceView.Renderer interface, thefollowing methods must be implemented:
onSurfaceCreated(): The system calls this methodonce, when creating the GLSurfaceView. Use it to set upenvironment or initialize graphic objects.onDrawFrame(): The system calls this method on eachredraw of the GLSurfaceView. Use it to draw graphicobjects.onSurfaceChanged(): The system calls this methodwhen the GLSurfaceView geometry changes, e.g.screen orientation change
Define a triangle
OpenGL allows you to define objects using coordinates inthree-dimensional space
By default, the coordinate (0,0,0) is the center of the screen,(1,1,0) is the top right, and (−1,−1,0) is the bottom left
private void initShapes() {float triangleCoords[] = { // X, Y, Z-0.5f, -0.25f, 0, 0.5f, -0.25f, 0, 0.0f, 0.559016994f, 0
};// initialize vertex Buffer for triangleByteBuffer vbb = ByteBuffer.allocateDirect(
// (# of coordinate values * 4 bytes per float)triangleCoords.length * 4);
vbb.order(ByteOrder.nativeOrder()); // use native byte ordertriangleVB = vbb.asFloatBuffer(); // create fp buffertriangleVB.put(triangleCoords); // add coords to fp buffertriangleVB.position(0); // set buffer to read 1st coord
}
Projection
Problem: OpenGL assumes a square, uniform coordinatesystem. Androids monitors usually vary in size and shape.
Solution in OpenGL ES 1.0: create a projection matrix usingthe geometry of the device screen
public void onSurfaceChanged(GL10 gl, int width, int height) {gl.glViewport(0, 0, width, height);
// make adjustments for screen ratiofloat ratio = (float) width / height;
// set matrix to projection modegl.glMatrixMode(GL10.GL_PROJECTION);
// reset the matrix to its default stategl.glLoadIdentity();
// apply the projection matrixgl.glFrustumf(-ratio, ratio, -1, 1, 3, 7);
}
Example: draw a rotating triangle
Widgets
App Widgets
Introduced in Android 1.5 (Cupcake)
App Widgets are miniature application views embedded inother applications (such as the Home screen) and receivedperiodic updates
These views are referred to as widgets
An application that is able to hold App Widgets is called an AppWidget host
Several App Widgets are shipped with Android, e.g. analogclock, music controller, picture frame
This section is about how to create your own widgets
Create an App Widget
Create res/xml/widget.xml
<?xml version="1.0" encoding="utf-8"?><appwidget-provider
xmlns:android="http://schemas.android.com/apk/res/android"android:minWidth="146dip"android:minHeight="72dip"android:updatePeriodMillis="1800000"android:initialLayout="@layout/main" />
to specify a minimum size of the widget, how often it should beupdated, and a reference to its starting layout
Create a BroadcastReceiver by subclassingAppWidgetProvider
public class Widget extends AppWidgetProvider {}
Create an App Widget (cont.)
Declare the broadcast receiver inside <application> inAndroidManifest.xml
<receiver android:name=".Widget"android:label="@string/widget_name"><intent-filter><actionandroid:name="android.appwidget.action.APPWIDGET_UPDATE"
/></intent-filter><meta-data android:name="android.appwidget.provider"android:resource="@xml/widget" />
</receiver>
To run, select Run As > Android Application as usual
Widgets can be opened by pressing and holding your finger (ormouse) on the Home screen
Example: HelloWidget
Update your widget
Implement onUpdate() to handle APPWIDGET_UPDATEintent, the action we declared in AndroidManifest.xml
Example:
private SimpleDateFormat formatter = new SimpleDateFormat("EEEEEEEEE\nd MMM yyyy");
@Overridepublic void onUpdate(Context context,
AppWidgetManager appWidgetManager, int[] appWidgetIds) {String now = formatter.format(new Date());
RemoteViews updateViews = new RemoteViews(context.getPackageName(), R.layout.main);
updateViews.setTextViewText(R.id.text, now);appWidgetManager.updateAppWidget(appWidgetIds, updateViews);
super.onUpdate(context, appWidgetManager, appWidgetIds);}
Explanations & tips
SimpleDateFormat is used to format the current date: day ofthe week, day of the month, month name, and year
RemoteViews is used for the new view layout that the widgetwill display
In this example, the same layout R.layout.main is used
The update frequency is controlled byandroid:updatePeriodMillis in res/xml/widget.xml.The value 1800000 is 30 minutes.
However, updates requested with updatePeriodMillis willnot be delivered more than once every 30 minutes
For more information, seehttp://developer.android.com/guide/topics/appwidgets/index.html
Calendar widget
Live wallpaper
Live wallpaper
Introduced in Android 2.1
Live wallpapers are rich, animated, interactive backgrounds onhome screens
Similar to normal app, a live wallpaper has access to allfacilities of the platform: SGL, OpenGL, GPS, accelerometers,network access, etc
Implementing a live wallpaper
Similar to implementing a service, with an additional methodonCreateEngine() to create WallpaperService.Engine
The engine is responsible for handling the lifecycle and drawingof a wallpaper
Drawing a wall paper can be expensive, so optimize your codeas much as possible
The Home application can send commands to theonCommands method of your live wallpaper:
android.wallpaper.tap: when the user taps an emptyspace on the workspaceandroid.home.drop: when the user drops an icon or awidget on the workspace
References
Article:http://developer.android.com/resources/articles/
live-wallpapers.html
Samples:http://developer.android.com/resources/samples/
CubeLiveWallpaper/index.html