Android Development Tutorial V3

japan linux symposium
android development tutorial
tokyo, october 2009

diego torres milano
diego@codtech.com
copyright © 2009 cod technologies ltd www.codtech.com

“I have always wished that my
computer would be as easy to
use as my telephone.
My wish has come true.
I no longer know how to use my
telephone.”

Bjarne Stroustrup


agenda
● introduction to android
● development environment
● building blocks
● your first android application
● testing and performance


introduction to android
after this section you will...

● identify unique features of
android platform
● compare android against
other platforms
● understand android building
blocks


what is android ?
● android is the first complete, open
and free mobile platform
● developed by Open Handset
Alliance
● software stack than includes
– operating system
– middleware
– key applications
– rich set of APIs Portions of this page are reproduced from work created and shared by
Google and used according to terms described in the Creative
Commons 2.5 Attribution License.


is android linux ?
NO, android is not linux !
android is based on a linux kernel
but it's not GNU/Linux
● no native windowing
system
● no glibc support
● no GNU/Linux utilities


so is android java ?
NO, android is not java !
android is not an implementation
of any of the Java variants
● uses the java language
● implements part of the
Java5 SE specification
● runs on a dalvik virtual
machine instead of JVM


android linux kernel
android is based on a linux 2.6 kernel, providing
rnel, p
● security
● memory management
● process management
● network stack
● driver model
● abstraction layer
kernel source: source.android.com


linux kernel enhancements
android introduces some linux kernel patches
● alarm
● ashmem
● binder
● power management
● low memory killer (no swap space available)
● logger


unique platform characteristics
android characteristics not found on other platforms

● open source

● “all applications are equal” model

● dalvik virtual machine


other characteristics
interesting features as well, but they are more
common across other mobile platforms
● application framework enabling reuse of components
● integrated browser based on WebKit OSS engine
● 3D graphics based on the OpenGL ES
● SQLite for structured data storage
● media support for common audio, video, and still images
● camera, GPS, compass, and accelerometer


android architecture

written in
C/C++
written
in java

register
based
VM
courtesy of Google


android development environment

● be aware of the components
needed to start developing

● know the tools available on
the android sdk


development environment
ubuntu is the perfect choice
● supported and tested by
Google
● all the necessary tools
available
● 32bit installation highly
recommended


development environment
Eclipse is an extensible development
platform
● much more than an IDE
● unfortunately no Eclipse
3.4 packages
● download from
http://eclipse.org and
install
● android ADT plugin


java

● installed from ubuntu repositories
● packages matching sunjava6*

diego@bruce:~$ java -version
java version "1.6.0_16"
Java(TM) SE Runtime Environment (build 1.6.0_16-
b01)
Java HotSpot(TM) Client VM (build 14.2-b01, mixed
mode, sharing)


android SDK 1.6 and ADT
● download from http://developer.android.com
and install to /opt directory

● create symbolic link /opt/android-sdk to
point to installed SDK

● add site
https://dlssl.google.com/android/eclipse/
to eclipse software updates for ADT


android sdk updater & avd

$ android


emulator

$ emulator @1.5_r3

dalvik debug monitor

$ ddms

zipalign
● optimizes the way an application is packaged
● potentially makes your application and system
run faster
● android accesses resources efficiently where
they are aligned on 4byte boundaries
● ADT automatically align release packages

$ zipalign -c -v 4 my.apk


sqlite database browser

$ sudo apt-get install sqlitebrowser


android building blocks

● recognize the fundamental
building blocks
● use these building blocks to
create applications
● understand applications
lifecycle


building blocks


Activities

● Activities are stacked
like a deck of cards
● only one is visible
● only one is active
● new activities are
placed on top


Activities lifecycle

rectangles are callbacks where
we can implement operations
performed on state changes


Activities states
● active
– at the top of the stack
● paused
– lost focus but still visible
– can be killed by LMK
● stopped
– not at the top of th stack
● dropped
– killed to reclaim its memory


Views

● Views are basic building blocks

● know how to draw themselves

● respond to events

● organized as trees to build up GUIs

● described in XML in layout resources


Views and Viewgroups
● Views and
Viewgroups trees
build up complex
GUIs
● android framework is
responsible for
– measuring
– laying out
– drawing


pattern: load layout

android compiles the XML layout code that is
later loaded in code usually by

public void onCreate(Bundle
savedInstanceState) {
...
setContentView(R.layout.filename);
...
}


pattern: ids

using an unique id in a XML View definition
permits locating it later in Java code

private View name;

public void onCreate(Bundle
savedInstanceState) {
...
name = (View)
findViewById(R.id.name);
...
}


Intents
● Intents are used to move from Activity to Activity
● describes what the application wants
● provides late runtime binding

primary attributes
attribute description
action the general action to be performed, such as VIEW,
EDIT, MAIN, etc.
data the data to operate on, such as a person record in
the contacts database, as URI


intent playground

install from android market or from
http://codtech.com/android/IntentPlayground.apk


Services
● services run in the background
● don't interact with the user
● run on the main thread
of the process
● is kept running as long as
– is started
– has connections


Notifications

● notify the user about
events
● sent through
NotificationManager
● types
– persistent icon
– turning leds
– sound or vibration


ConentProviders
● ContentProviders are objects that can
– retrieve data
– store data
● data is available to all applications
● only way to share data across packages
● usually the backend is SQLite
● they are loosely linked to clients
● data exposed as a unique URI

AndroidManifest.xml
● control file that tells
the system what to do
and how the toplevel
components are
related
● it's the “glue” that
actually specifies
which Intents your
Activities receive
● specifies permissions

your first android application
● create your own android map
project
● design the UI
● externalize resources
● react to events
● run the application


designing the UI
this simple UI designs
contains
● the window title
● a spinner (drop down
box) containing the
available locations
● a map displaying the
selected location
● zoom buttons

create project

android
target
version
unique
package
name


create test project

test
package
name


run configurations

if phone is
connected

android
target
version


default application
● autogenerated
application template
● default resources
– icon
– layout
– strings
● default
AndroidManifest.xml
● default run
configuration

create the layout
● remove layout
● add a RelativeLayout
● add a View (MapView not
supported by ADT)

● replace View by
com.google.android.m
aps.MapView
● change id to MapView
● add a Spinner filling
parent width

run the application
● com.google.android.
maps it's an optional
library not included by
default
● edit Android Manifest
● add Uses Library
com.google.android.m
aps as Application
node


google maps api key
● checking DDMS logcat we find
java.lang.IllegalArgumentException: You need to
specify an API Key for each MapView.

● to access Google Maps we need a key
● application must be signed with the same key
● key can be obtained from Google
● MapView should include
android:apiKey="0GNIO0J9wdmcNm4gCV6S0nlaFE8bHa9W
XXXXXX"


obtaining google maps api key

● $ keytool -list
-alias
androiddebugkey
-keystore
~/.android/debug.k
eystore
your
fingerprint
● http://code.google.co
m/android/mapsapi
signup.html


MapActivity
● checking DDMS logcat again

java.lang.IllegalArgumentException: MapViews can
only be created inside instances of MapActivity.

● change base class to MapActivity

● fix imports

● add unimplemented methods


where is the map ?
● still no map displayed
● check DDMS logcat
● errors displayed
● a permission is missing
– INTERNET

● add it to Manifest


finally our map

still some problems ...
● spinner is covered
android:layout_alignPa
rentTop="true"

● spinner has no prompt
prompt: @string/prompt

● externalize resource
value Select a location


pattern: adapters

an Adapter object acts as a bridge between an
AdapterView and the underlying data for that view

ArrayAdapter<CharSequence> adapter =
ArrayAdapter.createFromResource(
this, R.array.array,
android.R.layout.layout);

view.setAdapter(adapter);

The Adapter is also responsible for making a View for each item in the
data set.


pattern: resources

resources are external files (that is, noncode files)
that are used by your code and compiled into your
application at build time.

<resources>
<string-array name=”array”>
<item>item</item>
</string-array>
</resources>

res = getResources().getType(id);


locations.xml
<?xml version="1.0" encoding="UTF-8"?>

<resources>


<string-array name="location_names">
<item>Akihabara Convention Hall</item>
<item>Hotel Villa Fontaine</item>
<item>Narita Intl. Airport</item>
</string-array>

<string-array name="locations">
<item>35.699434,139.772079,16</item>
<item>35.669012,139.765384,14</item>
<item>35.773118,140.379181,12</item>
</string-array>
</resources>

http://android.codtech.com/jls2009/locations.xml

complete the class
● create the locations array field
locations =
getResources().getStringArray(R.array.locations);

● find the views (ids pattern)
spinner = (Spinner) findViewById(R.id.Spinner01);
mapView = (MapView) findViewById(R.id.MapView);

● create the adapter
final ArrayAdapter<CharSequence> adapter =
ArrayAdapter.createFromResource(this,
R.array.location_names,
android.R.layout.simple_spinner_item);
spinner.setAdapter(adapter)


almost there
● map is displayed
● spinner is displayed
● drop down is
displayed
● but there's no
selection button ...
adapter.
setDropDownViewResource(
android.R.layout.
simple_spinner_dropdown_item
);


respond to events
● when an item is
selected map should
be centered at that
location
spinner.
setOnItemSelectedListener(
new
OnItemSelectedListener() {
});

● in the listener invoke
goToSelectedLocation(ar
g2);


goToSelectedLocation
protected void goToSelectedLocation(int position) {
String[] loc = locations[position].split(",");

double lat = Double.parseDouble(loc[0]);
double lon = Double.parseDouble(loc[1]);
int zoom = Integer.parseInt(loc[2]);

GeoPoint p = new GeoPoint((int)(lat * 1E6),
(int)(lon * 1E6)); mapController
should be
Log.d(TAG, "Should go to " + p); initialized in
onCreate
mapController.animateTo(p);
mapController.setZoom(zoom);
}

http://android.codtech.com/jls2009/goToSelectedLocation.txt


more events
● turn map clickable
android:clickable="true”
● override onKeyDown
switch (keyCode) {
case KeyEvent.KEYCODE_I:
mapController.zoomIn();
break;
case KeyEvent.KEYCODE_O:
mapController.zoomOut();
break;
case KeyEvent.KEYCODE_S:
mapView.setSatellite(
!mapView.isSatellite());
break;
}

http://android.codtech.com/jls2009/onKeyDown.txt


zoom controls
● add a FrameLayout
● align to parent bottom
● in onCreate
...
zoomControls =
(ViewGroup)findViewById(
R.id.FrameLayout01);

... mapView.setBuiltInZ
oomControls(true);

zoomControls.addView(
mapView.getZoomControls());


we did it !
● Some things to try
– select a location

– pan

– zoom in

– zoom out

– toggle satellite


japanese localization

existing
resource

new
language


japanese application

● resources
automatically selected
● match phone locale
● no programming
needed


hierarchyviewer – tree

properties

selected
view
highlighted

selected
view


hierarchyviewer zoom
selected
pixel

pixel
color


“Remember that there is no
code faster than no code”
Taligent's Guide to Designing Programs


testing and performance

● understand the best practices
to develop for android
● identify the alternatives to test
units, services and applications
● performance


best practices
● consider performance, android is not a desktop
● avoid creating objects
● use native methods
● prefer virtual over interface
● prefer static over virtual (if no object access required)
● avoid internal getter/setters
● declares constants final
● avoid enums


testing
● android sdk 1.6 features
– creation of test projects
– ActivityUnitTestCase to run isolated unit tests
– ServiceTestCase to test services
– ActivityInstrumentationTestCase2 to run functional
tests of activities
● ApiDemos includes some test samples
● monkey, generates pseudorandom of user
events

1000000
1500000
2000000
2500000
3000000

500000

0
Add a local variable

Add a member variable

Call String.length()

Call empty static native method

Call empty static method
performance

Call empty virtual method

Call empty interface method

Call Iterator:next() on a HashMap

Call put() on a HashMap

Inflate 1 View from XML

Inflate 1 LinearLayout with 1 TextView

Inflate 1 LinearLayout with 6 View

Inflate 1 LinearLayout with 6 TextView

Launch an empty activity
Time

traceview

// start tracing to sdcard
Debug.startMethodTracing(“mytrace”);


dmtracedump

$ sudo aptget install graphviz

“If things seem under control,
you're not going fast enough.”
Mario Andretti


thank you
android development tutorial
tokyo, october 2009

diego torres milano
diego@codtech.com


Android Development Tutorial V3

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Android Development Tutorial V3

Similar to Android Development Tutorial V3 (20)

Android Development Tutorial V3