The document provides an introduction and overview of developing Android applications. It discusses what Android is, the major Android application components of Activities, Services, Intents, and Content Providers. It outlines the Android development environment, including installing the SDK and creating a sample "Hello World" application. It also covers the key parts of an Android project like the AndroidManifest file, resources, and source code directories. The document aims to guide users through the essentials of Android application development without assuming prior Java knowledge.
2. The Big Picture
What is Android?
Get you an idea of how to start developing Android
applications
Introduce major Android application concepts
Walk you through a sample application in the
development environments
Install the development environments
Create the first Android Application
Goals
3. NOT a super difficult course
Guide you to go through essentials (tons of resources are available)
NOT a Java language class
Learn how to use the Android SDK APIs
NOT an Android internal course
Learn Android Application Development
NOT a lecture oriented course
Learn by doing the hands-on programming
NOT an advanced course
Introduce from the very basics (tool installation)
4. What is Android?
System architecture
Develop environment installation
Hello World!
Application components
Tool chain
Agenda
5. Android’s web page:
http://developer.android.com/sdk/index.html
6. Android SDK (http://developer.android.com)
Windows, Linux, Mac
Utilizes the Java language
Different Libraries
Well-documented
http://developer.android.com/reference/packages.html
Freely downloaded
7. Android
Android versions
Android 1.5 (Apr. 2009) – Cupcake
First really stable/robust version
Android 1.6 (Sep. 2009)– Donut
First ‘updatable’ version
Android 2.0 (Oct. 2009) / Android 2.1 (Jan. 2010)– Éclair
Android 2.2 (May. 2010) – Froyo
Android 2.3 (Q4 2010) – Gingerbread
Android 3.0 (Honeycomb)
Android 4.0 (Ice Cream Sandwich)
Android 4.2 (Jelly Bean)
Android 4.4 (Kitkat)
http://en.wikipedia.org/wiki/Android_(operating system)
Versioning
Higher version addressed many issues
Better audio/video
Better sensing
Use of GPS
Multi touch
Other
8. Android is a mobile operating system initially developed by
Android Inc (bought by Google 2005).
Android is the software platform from Google and the
Open Handset Alliance (OHA) that has the potential to
revolutionize the global cell phone market.
A free, open source mobile platform
Android is not a device or a product
Android™ consists of a complete set of software components for
mobile devices including:
an operating system (Linux-based, multiprocess, multithreaded OS),
middleware, and
key mobile applications.
It has the capability to make inroads in many other (non‐phone)
embedded application markets such as a tablet, a DVR, a
handheld GPS, an MP3 player, etc.
9. Android Open Source Project web page to download the source
http://source.android.com/download
How many lines of code does it take to create the Android OS?
http://www.gubatron.com/blog/2010/05/23/how-many-
lines-of-code-does-it-take-to-create-the-android-os/
10. Listen from the project creators/developers (2.19 min)
Nick Sears. Co‐founder of Android
Steve Horowitz. Engineering Director
You will hear statements such as
“…currently it is too difficult to make new products … open software brings more innovation
… choices … lower costs … more applications such as family planner, my taxes,
understand my wife better, … ”
11. Quoting from www.OpenHandsetAlliance.com page
“… Open Handset Alliance™, a group of 47 technology and
mobile companies have come together to accelerate innovation
in mobile and offer consumers a richer, less expensive, and
better mobile experience.
Together we have developed Android™, the first complete,
open, and free mobile platform.
We are committed to commercially deploy handsets and
services using the Android Platform. “
12.
13. Short video (4 min.)
Showing Dave Bort and Dan
Borstein, two members of
the Android Open Source
Project talk about the
project.
See Android Developers
http://www.youtube.com/watch?v=7Y4thikv-OM
14. Android is a software environment built for mobile devices.
It is not a hardware platform.
Android includes:
Linux kernel‐based OS,
a rich UI,
telephone functionality,
end‐user applications,
code libraries,
application frameworks,
multimedia support, ...
User applications are built for Android in Java.
The Android Platform
Again, what did they say about Android?
17. Have all of the major components of computing platform, but specially
designed for the mobile environment
(NOT a general purpose computing environment).
Application framework enabling reuse and replacement of components
Dalvik virtual machine optimized for mobile devices
Integrated browser based on the open source WebKit engine
Optimized graphics powered by a custom 2D graphics library; 3D graphics
based on the OpenGL ES specification (hardware acceleration optional)
SQLite for structured data storage
Media support for common audio, video, and still image formats (MPEG4,
H.264, MP3, AAC, AMR, JPG, PNG, GIF)
GSM Telephony (hardware dependent)
Bluetooth, EDGE, 3G, and WiFi (hardware dependent)
Camera, GPS, compass, and accelerometer (hardware dependent)
Rich development environment including a device emulator, tools for
debugging, memory and performance profiling, and a plugin for
the Eclipse IDE
20. Linux kernel is a proven core platform.
Reliability is more important than performance when it comes
to a mobile phone, because voice communication is the
primary use of a phone.
Linux can help meet this requirement.
Linux provides a hardware abstraction layer, letting the upper
levels remain unchanged despite changes in the underlying
hardware.
As new accessories appear on the market, drivers can be
written at the Linux level to provide support, just as on other
Linux platforms.
21. User applications, as well as core Android applications, are
written in the Java programming language and are compiled
into byte codes.
Android byte codes are interpreted at runtime by an
interpreter known as the Dalvik virtual machine.
Why another Virtual Machine?
Android byte code files are logically equivalent to Java byte codes,
but they permit Android to
run its applications in its own virtual environment that is free from
Sun’s licensing restrictions and
an open platform upon which Google, and potentially the open source
community, can improve as necessary.
Being optimized for low memory requirements
The VM was slimmed down to use less space
The constant pool has been modified to use only 32-bit indexes to
simplify the interpreter
24. There are four building blocks (components) to an Android
application:
Activity represents a screen of the app. Moving from one activity
to another is done using an Intent
An Intent describes what an application wants done, in terms of the
action and the data to act upon, e.g. PICK a contact
Intent Receiver (broadcast receiver) is used when you want code
in your application to execute in reaction to an external event,
e.g. when the phone rings
Service is a faceless tasks that run in the background, like a sync
session
Content Provider is a class that implements a standard set of
methods to let other applications store and retrieve the type of
data that is handled by that content provider
Application Anatomy
25. Android Development
Applications are composed of:
o Activities
Visual user interface for one focused endeavor
o Services
Runs in the background for an indefinite period of time
Intents
Asynchronous/ synchronous messaging
URL dispatching on steroids
Glues many Activities and Services together to make an application
Provides interactivity between applications
27. Android application runs in its own Linux process
The process lifetime is handled by the system, not by the app:
when the system needs memory to run new applications, one of
the background app is killed
That's why it is important to use correctly Activities, Services,
and Intent Receivers
Not using them in the right way can result in the system killing
the application's process while it is doing important work
Example: starting a thread to download a file from an Activity or an
IntentReceiver. A Service should be used instead.
Life Cycle of an
Android Application
28. Android determines which process to kill when low on memory
with this priority:
Foreground process: is one that is required for what the user is
currently doing (UI interaction, handling an Intent, etc.)
Visible process: is one holding an Activity that is visible to the user
on-screen but not in the foreground (a foreground window leaves
this visible in the background)
Service process: is one holding a Service that is invisible to the
user, but is doing something valuable (e.g. Playing music)
Background process: is one holding an Activity that is not currently
visible to the user
Empty process: is one that doesn't hold any active application
components. It is kept only as a cache to improve startup time the
next time an application's component needs to run
Process priority
29. Application Lifecycle
• Designed to protect battery life
• Activities live on a stack
• Background activities can be killed at
any moment
• The platform makes it easy for
developers to code applications that
are killed at any moment without
losing state
o Helps with DoS issues
http://www.android.com/media/#platform-architecture#android-20
33. Building Blocks of an
Application
Resources
Images
Audio files
Constants
Stored in ‘res’ directory
Permissions
Must explicitly ask permission to perform tasks
Access web
Access GPS
Access Contacts
34.
35. Project identification
When creating a new project, the following must be
provided
Project name
Displayed in Eclipse to differentiate projects
Application name
Activity name
The first screen displayed when the application is launched
Package name
com.csci153.name
36. Project components
Automatically created
AndroidManifest.xml
Referenced libraries
Important directories
gen (generated)
res (resources)
src (source)
37. Project components
AndroidManifest.xml
Global settings
Permissions
Activities
Intents
Referenced libraries
android.jar – standard Android library
can add other user-defined libraries
38. Project components
gen directory
Contains R.java
Automatically generated file
Contains pointers to other files and folders
Never modified by programmer
39. Project components
res directory
Contains other folders
drawable
Contains image files (icons, background)
layout
Contains .xml layout files
One for each activity
main.xml is layout for the default activity
values
Contains string pointers that can be used throughout the code
40. Project components
src directory
Contains the java source code
One .java file for each activity
<activity>.java for the default activity (matches activity name)
x.java for other activities (matches corresponding .xml name)
42. Manifest file
AndroidManifest.xml
required
Indicates:
xml namespace and version
application information
activities
Android SDK version
activities used within the app
services that will be used (Web, phone, etc.)
other aspects
44. Manifest File
Exploring the <application> tag
android:icon=“@drawable/icon”
Icon to display in the drawer
android:label="@string/app_name“
Name of the icon in the drawer
<activity>
child of <application>
45. Manifest File
Exploring the <activity> tag
android:name=“.Hello”
Associated .java file
short for packagename.Hello
i.e. com.csci153.examples.Hello
android:label=“@string/app_name”
Text that appears in title bar when this activity is displayed
<intent-filter>
child of <activity>
46. Manifest File
Exploring the <intent-filter> tag
<action android:name="android.intent.action.MAIN" />
Indicates this is the main entry point of the application
<category android:name="android.intent.category.LAUNCHER" />
Indicates that the activity should be launched
Without these lines, the application is started but no activity is
presented
intent-filters ‘filter’ what an object can do – if there is no action defined
within the filter, they implicitly deny that the action can be performed
47.
48. Intent
Class within Android
android.content.Intent
contains information regarding some action to be
performed
starting the phone dialer
starting an activity
opening a web page
other
49. Intent Example
Starting the phone dialer
Intent intent = new
Intent(Intent.ACTION_DIAL,Uri.parse("tel:5551234"));
startActivity(intent);
50. Intent Example
Opening a web page
Intent intent = new
Intent(Intent.ACTION_VIEW,Uri.parse
(”http://www.google.com”));
startActivity(intent);
51. Intent Example
Opening an Activity
Intent intent = new Intent(this, Screen2.class);
startActivity(intent);
this refers to the current activity
Screen2.class refers to the class file associated with the new
activity to be opened
implies a corresponding Sreen2.java file exists
activity MUST be referenced in the manifest file
52. Intents
Helpful hints about Intents
The intent class has many methods
put… to add information to the intent
get… to retrieve information from an intent
many others
some of these may provide useful when one Activity launches
another
53. Activities
Helpful hints about Activities
Each Activity will have a corresponding .xml and .java file
Remember to reference each Activity in the manifest file
The Activity class has a method to retrieve the intent that
initiated it (onCreate)
The Activity class has many methods, some of which monitor
events associated with it
on… (onResume, onStop, …
some of these may provide useful when one Activity launches
another
55. 3.2 IDE and Tools
Android SDK
• Class Library
• Developer Tools
dx – Dalvik Cross-Assembler
aapt – Android Asset Packaging Tool
adb – Android Debug Bridge
ddms – Dalvik Debug Monitor Service
• Emulator and System Images
• Documentation and Sample Code
Eclipse IDE + ADT (Android Development Tools)
• Reduces Development and Testing Time
• Makes User Interface-Creation easier
• Makes Application Description Easier
3. Software development (2)
56. Emulator
• QEMU-based ARM emulator runs same system image as a device
• Use same toolchain to work with devices or emulator
3. Software development (2)
57. Layouts
Define the user interface for an activity
Layouts are defined in .xml files
within /res/layout folder
different layout can be designed for landscape view
placed within /res/layout-land folder
Handful of layouts to choose from
All derived from the class:
android.view.ViewGroup
58. Layouts
Available layouts
AbsoluteLayout
Deprecated as of 1.5
Allows specific x, y coordinates
LinearLayout
Default
Allows child items to be placed in a single row or column
RelativeLayout
Allows child itmes to be placed relative to each other
TableLayout
Allows child items to be placed in multiple rows and columns
FrameLayout
Allows child items to be stacked on one another
We will not cover
59. Android
Dalvik Virtual Machine
Android’s equivalent of JVM
Optimized for low memory-management
Written by Dan Bornstein (named after a village where relatives lived)
AVD
Android Virtual Device
Phone Emulation
ADB
Android Debug Bridge
Allows access and control over emulators
DDMS
Dalvik Debug Monitor Service
Middleman between IDE and applications
Communications with ADB to provide control
Telephony
Location
Other
60. Building Blocks of an
Application
Activities
User interface screen
Each application can have multiple activities
Layout defined in .xml file
Functionality defined in .java file
Intents
Intention to perform a task
Explicitly stated in code
Launch an activity
Display a webpage
Broadcast a notification
61. Building Blocks of an
Application
Services
Task that runs in the background
Music Player
RSS reader that updates an activity when a site is updated
Content Providers
Bundles data so it can be shared among multiple applications