Architecting Android Apps: Marko Gargenta

Architecting
Android Apps
Marko Gargenta @Marakana

About Marko Gargenta

Entrepreneur, Author, Speaker
Developer of Android Bootcamp for Marakana.
Instructor for 1,000s of developers on Android at Qualcomm, Cisco,
Motorola, Intel, DoD and other great orgs.
Author of Learning Android published by O’Reilly.
Speaker at OSCON (4x), ACM, IEEE(2x), SDC(2x), AnDevCon(2x),
DroidCon.
Co-Founder of SFAndroid.org
Co-Chair of Android Open conference: Android Open

Architecting Android Apps Overview
The goal of this module is to introduce you to main components used to
create Android apps. By the end of this module, you should have a good
idea what Android app building blocks are, and their key properties.
Seven iterations of an app:
Part 1 - Activities and Android UI
Part 2 - Intents, Action Bar, and More
Part 3 - Services
Part 4 - Content Providers
Part 5 - Lists and Adapters
Part 6 - Broadcast Receivers
Part 7 - App Widgets

Yamba

Objectives of Yamba
The objective of this module is to explain how to go about designing a
typical Android app. You will have a chance to see an example app,
Yamba, using most of the standard Android building blocks. By the end
of this talk, you should have high-level understanding about designing
an Android app.

Yamba Approach
Yamba Overview
Yamba: Yet Another Micro-Blogging App
Comprehensive Android example application.
Works with services that support Twitter API.

Project Philosophy
Small increments - build it organically
App must always run - whole and complete
Refactor when needed - do simplest thing first

Part 1 - Activities and Android UI

Activity Overview

An activity is roughly a screen.
A typical application may have many activities.
Activities are typically expensive and so are managed by the
system.

Activity Lifecycle

Activities are highly managed by the system’s ActivityManager.
ActivityManager drives the activity through its states.
You as an app developer get to say what happens on transitions.

Activity Lifecycle Explored
Starting for the first time

DAtvtDm(60) oCet
/ciiyeo 78: nrae
DAtvtDm(60) oSat
/ciiyeo 78: ntr
DAtvtDm(60) oRsm
/ciiyeo 78: neue

Opening another activity, then clicking Back button

..
.
DAtvtDm(60) oCiknteAtvt
/ciiyeo 78: nlcAohrciiy
DAtvtDm(60) oPue
/ciiyeo 78: nas
DAtvtDm(60) oSo
/ciiyeo 78: ntp
DAtvtDm(60) oRsat
/ciiyeo 78: netr
DAtvtDm(60) oSat
/ciiyeo 78: ntr
DAtvtDm(60) oRsm
/ciiyeo 78: neue

Rotating the screen

..
.
DAtvtDm(60) oPue
/ciiyeo 78: nas
DAtvtDm(60) oSo
/ciiyeo 78: ntp
DAtvtDm(60) oDsry
/ciiyeo 78: neto
DAtvtDm(60) oCet
/ciiyeo 78: nrae
DAtvtDm(60) oSat
/ciiyeo 78: ntr
DAtvtDm(60) oRsm
/ciiyeo 78: neue

Pressing Home button

..
.
DAtvtDm(60) oPue
/ciiyeo 78: nas
DAtvtDm(60) oSo
/ciiyeo 78: ntp

Restarting form the StatusBar

..
.
DAtvtDm(60) oRsat
/ciiyeo 78: netr
DAtvtDm(60) oSat
/ciiyeo 78: ntr
DAtvtDm(60) oRsm
/ciiyeo 78: neue

Activity Template
ActivityDemo.java

pcaecmmrkn.nri.ieyl;
akg o.aaaaadodlfcce

ipr adodapAtvt;
mot nri.p.ciiy
ipr adodcnetCnetaus
mot nri.otn.otnVle;
ipr adodcnetItn;
mot nri.otn.net
ipr adodo.ude
mot nri.sBnl;
ipr adodui.o;
mot nri.tlLg
ipr adodve.eu
mot nri.iwMn;
ipr adodve.eutm
mot nri.iwMnIe;
ipr adodve.iw
mot nri.iwVe;

pbi casAtvtDm etnsAtvt {
ulc ls ciiyeo xed ciiy
sai fnlSrn TG="ciiyeo;
ttc ia tig A AtvtDm"

/ --Lfccemtos
/ - ieyl ehd

@vrie
Oerd
pbi vi oCet(udesvdntnett){
ulc od nraeBnl aeIsacSae
sproCet(aeIsacSae;
ue.nraesvdntnett)
stotnVe(.aotmi)
eCnetiwRlyu.an;
LgdTG "nrae)
o.(A, oCet";
}

@vrie
Oerd
poetdvi oSat){
rtce od ntr(
sproSat)
ue.ntr(;
LgdTG "ntr";
o.(A, oSat)
}

@vrie
Oerd
poetdvi oRsm( {
rtce od neue)
sproRsm(;
ue.neue)
LgdTG "neue)
o.(A, oRsm";
}

@vrie
Oerd
poetdvi oPue){
rtce od nas(
sproPue)
ue.nas(;
LgdTG "nas";
o.(A, oPue)
}

@vrie
Oerd
poetdvi oSo( {
rtce od ntp)
sproSo(;
ue.ntp)
LgdTG "ntp)
o.(A, oSo";
}

@vrie
Oerd
poetdvi oRsat){
rtce od netr(
sproRsat)
ue.netr(;
LgdTG "netr";
o.(A, oRsat)
}

@vrie
Oerd
poetdvi oDsry){
rtce od neto(
sproDsry)
ue.neto(;
LgdTG "neto";
o.(A, oDsry)
}

/ --Otosmn mtos
/ - pin eu ehd

@vrie
Oerd
pbi boenoCetOtoseuMn mn){
ulc ola nraepinMn(eu eu

gteunltr)ifaeRmn.eu mn)
eMnIfae(.nlt(.eumn, eu;
rtr tu;
eun re
}

@vrie
Oerd
pbi boenoOtostmeetdMnIe ie){
ulc ola npinIeSlce(eutm tm
sic (tmgttmd) {
wth ie.eIeI()
cs Ri.tmsatsrie
ae .die_tr_evc:
satevc(e Itn(hs Srieeocas)
trSrienw netti, evcDm.ls);
rtr tu;
eun re
cs Ri.tmso_evc:
ae .die_tpsrie
soSrienwItn(hs Srieeocas)
tpevc(e netti, evcDm.ls);
rtr tu;
eun re
cs Ri.tmrfeh
ae .die_ers:
satevc(e
trSrienw
Itn(mrkn.netato.netevcDm")
net"aaaaitn.cinItnSrieeo);
rtr tu;
eun re
cs Ri.tmsn_racs:
ae .die_edbodat
snBodatnw
edracs(e
Itn(mrkn.netato.eevreo);
net"aaaaitn.cinRcieDm")
rtr tu;
eun re
cs Ri.tmlcto:
ae .die_oain
satciiynwItn(hs
trAtvt(e netti,
SseSrieDm.ls);
ytmevcseocas)
rtr tu;
eun re
cs Ri.tmisr:
ae .die_net
gtotnRsle(
eCneteovr)
.netPoieDm.OTN_R,nw
isr(rvdreoCNETUI e
Cnetaus);
otnVle()
rtr tu;
eun re
cs Ri.tmqey
ae .die_ur:
gtotnRsle(.ur(rvdreoCNETUI
eCneteovr)qeyPoieDm.OTN_R,
nl,nl,nl,
ul ul ul
nl)
ul;
rtr tu;
eun re

}

rtr fle
eun as;
}

/ --Bto cikeethnlr
/ - utn lc vn ade

pbi vi oCiknteAtvt(iwv {
ulc od nlcAohrciiyVe )
satciiynwItn(hs Aohrciiycas)
trAtvt(e netti, nteAtvt.ls);
LgdTG "nlcAohrciiy)
o.(A, oCiknteAtvt";
}

}

Activity Callbacks
Lifecycle
oCet(
nrae)
Used to setup your activity. You will almost always have to have it.
Good place to inflate the UI and setup listeners.
o R s m ( and o P u e )
neue) nas(
Use them to turn on and off things that you’d like to have running only
while the activity is visible. This is important for things that consume a
lot of battery, such as GPS and sensors.
o S a t )and o S o (
ntr( ntp)
Use to setup code that starts/stops the activity. Unlike o R s m ( and
neue)
o P u e ) it includes Paused state as well.
nas(,

oRsat)
netr(
Called when the activity is restarted. It is followed by o S a t )and
ntr(
oRsm(.
neue)

oDsry)
nito(
A good place to do any cleanup before the activity is cleaned up from
memory. This is the counter-part to o C e t ( .
nrae)

Other
o C e t O t o s e u )and o O t o s t m e e t d )
nraepinMn( npinIeSlce(
Use them to setup your menu. o O t o s t m e e t d )loads the
npinIeSlce(
menu, typically from an XML resource. o O t o s t m e e t d )is
npinIeSlce(
called whenever an option menu item is clicked on.
Various listeners and event handlers, such as o C i k )
nlc(

Registering Activity
Main Activity
Register the activity in the Android Manifest file:
Android Manifest file

..
.
<ciiy
atvt
adodnm=.ciiyeo
nri:ae"AtvtDm"
adodlbl"srn/p_ae>
nri:ae=@tigapnm"
<netfle>
itn-itr
<cinadodnm=adoditn.cinMI"/
ato nri:ae"nri.netato.AN >
<aeoyadodnm=adoditn.aeoyLUCE"
ctgr nri:ae"nri.netctgr.ANHR
/>
<itn-itr
/netfle>
<atvt>
/ciiy
..
.

The intent filter specifies that this activity is to be the main entry point
into the application as well as that it should be shown in the app
launcher on home screen.

Any other activity

..
.
<ciiyadodnm=.nteAtvt"<atvt>
atvt nri:ae"Aohrciiy>/ciiy
..
.

Building Android UI
There are two approaches to building Android UI:

Declaratively
Declare UI in XML
Eclipse provides nice drag-n-drop tools
Inflate the XML views in Java

Programmatically
Instantiate all widgets programmatically
Set properties for each

The best is to use both:

1. Star with declaring the look and feel using XML

2. Inflate XML into Java

3. Finish by programming the actions using Java

Part 2 - Intents, Action Bar, and More

Intent Overview

Intents are like events or messages.
You can use them so start activities, start/stop services, or send
broadcasts.
Intents can be implicit or explicit.

Using Intents
satciiy)
trAtvt(
Starts an activity specified by the intent. If activity does not exist
already, it calls o C e t ( to create it. Otherwise, it calls o S a t )
nrae) ntr(
and o R s m )
neu(.

satevc(
trSrie)
Starts a service. Even if the service is not created yet, it called
o C e t ( on the service first.
nrae)

soSrie)
tpevc(
Stops a service that is already running. If service is not running, it does
nothing.
bnSrie)
idevc(
Binds to a service. Requires that the service returns a binder via
o B n ( method.
nid)

snBodat)
edracs(
Sends a broadcast. If there’s a broadcast receiver registered to filter for
the same action as this intent is specifying, that receiver’s o R c i e )
neev(
method will be called.

Explicit and Implicit Intents
Explicit Intent
ActivityDemo.java

..
.
satciiynwItn(hs Aohrciiycas)
trAtvt(e netti, nteAtvt.ls);
..
.
satevc(e Itn(hs Srieeocas)
trSrienw netti, evcDm.ls);
..
.

t i is the context from which this intent is being
hs sent, in our case an
Activity.

Implicit Intent
ActivityDemo.java

..
.
satevc(e
trSrienw
Itn(mrkn.netato.netevcDm")
net"aaaaitn.cinItnSrieeo);
..
.
snBodatnw
edracs(e
Itn(mrkn.netato.eevreo);
net"aaaaitn.cinRcieDm")
..
.

Requires that there’s an intent filter filtering for this particular intent,
for example:
AndroidManifest.xml

..
.
<evc adodnm=.netevcDm"
srie nri:ae"ItnSrieeo>
<netfle>
itn-itr
<cin
ato
adodnm=mrkn.netato.netevcDm"/
nri:ae"aaaaitn.cinItnSrieeo >
<itn-itr
/netfle>
<srie
/evc>
..
.
<eevradodnm=.eevreo>
rcie nri:ae"RcieDm"
<netfle>
itn-itr
<cinadodnm=mrkn.netato.eevreo
ato nri:ae"aaaaitn.cinRcieDm"
/>
<itn-itr
/netfle>
<rcie>
/eevr
..
.

Intent Filter
Intent filter is a way for us to assign certain action to an activity,
service, receiver or similar.
Action is one of system defined actions, or something you come up
with.
Intent filter typically goes into Android Manifest file, within
< c i i y , < e v c > or < e e v r elements.
atvt> srie, rcie>


..
.
<netfle>
itn-itr
<cinadodnm=sm.cinge.ee /
ato nri:ae"oeato.oshr" >
<itn-itr
/netfle>
..
.

Action Bar
The action bar, introduced in Honeycomb (API 11) is a title bar that
includes:

The application icon
The activity title
A set of user-selectable actions (optional)
A set of user-selectable navigation modes (optional)

Enabling the Action Bar
Android automatically displays an action bar on an API 11+ system if
the < s s s k element of your applications manifest:
ue-d>

Sets m n d V r i nto 11 or later, or
iSkeso

Sets t r e S k e s o to 11 or later
agtdVrin

Either or these settings enable the "holographic look and feel"
introduced in Honeycomb, which includes action bar support.

If neither m n d V r i nnor t r e S k e s o are set to 11+,
iSkeso agtdVrin
then an API 11+ system renders the app in a legacy theme, without
action bar support.

With the action bar enabled, legacy option menu items appear
automatically in the action bar’s overflow menu. You reveal the overflow
menu with:

The hardware Menu button (if present), or
An additional button in the action bar (for devices without a
hardware Menu button)

Adding Action Items
To display an option menu item as an action item, in the menu resource
file add a d o d s o A A t o = i R o "to the < t m element.
nri:hwscin"fom ie>

The device will display the item if there is room available in the
action bar, otherwise the item appears in the overflow menu.
Devices running API 10 or earlier ignore the s o A A t o
hwscin
attribute.

If your menu item supplies both a title and an icon, the action item
shows only the icon by default.

To display the text title, add w t T x to the
ihet
a d o d s o A A t o attribute. For example:
nri:hwscin

<xlvrin"."ecdn=uf8?
?m eso=10 noig"t-">
<eu
mn
xlsadod"tp/shmsadodcmakrsadod>
mn:nri=ht:/cea.nri.o/p/e/nri"
<tmadodi=@i/eusv"
ie nri:d"+dmn_ae
adodio=@rwbei_eusv"
nri:cn"daal/cmn_ae
adodtte"srn/eusv"
nri:il=@tigmn_ae
adodsoAAto=iRo|ihet /
nri:hwscin"fomwtTx" >
<mn>
/eu

The w t T x value is a hint to the action bar. The action bar will
ihet
show the title if possible, but might not if an icon is available and the
action bar is constrained for space.

ICS Split Action Bars
API 14 introduced split action bar support.
Enabling split action bar allows a device with a narrow screen to
display a separate action bar at the bottom of the screen
containing all action items.

You enable split action bar in the manifest add
uOtos"piAtoBrhnarw:
ipin=sltcinaWeNro"

To an < c i i y element to enable split action bar for that
atvt>
activity, or
To the < p l c t o >element to enable split action bar for all
apiain
activities

Devices on API 13 or earlier ignore the u O t o sattribute.
ipin

Using the App Icon for Navigation
You can enable the application icon — which appears in the action bar
on the left side — to behave as an action item. If enabled, your app
should respond by:
Going to the application "home" activity, or
Navigating "up" the application’s structural hierarchy

When the user taps the app icon, the system calls your activity’s
o O t o s t m e e t d )method. The M n I e passed as an
npinIeSlce( eutm
argument has an ID of a d o d R i . o e
nri..dhm.

The app icon was enabled by default in APIs 11-13. API 14 disables it
be default. To enable it in API 14 or later:

i (ul.ESO.D_N >
f BidVRINSKIT
BidVRINCDSIECEMSNWC){
ul.ESO_OE.C_RA_ADIH
gtcina(.eHmBtoEaldtu)
eAtoBr)stoeutnnbe(re;
}

Service Overview

Services are code that runs in the background.
They can be started and stopped. Services doesn’t have UI.
Keep in mind that service runs on the main application thread, the
UI thread.

Service Lifecycle

Service starts and "runs" until it gets a request to stop.
Service will run on the main UI thread.
To offload work from main thread, use intent service.
Intent service uses worker thread, stops when done with work.
Services can be bound or unbound.

Service Lifecycle Explored
Starting a service first time

DSrieeo 72) oCet
/evcDm( 63: nrae
DSrieeo 72) oSatomn
/evcDm( 63: ntrCmad

Restarting the same service

..
.
DSrieeo 72) oSatomn
/evcDm( 63: ntrCmad

Stopping the service

..
.
DSrieeo 72) oDsry
/evcDm( 63: neto

Starting the intent service

DItnSrieeo 74) oCet
/netevcDm( 78: nrae
DItnSrieeo 74) oHnlItn frato:
/netevcDm( 78: nadenet o cin
mrkn.netato.netevcDm
aaaaitn.cinItnSrieeo
DItnSrieeo 74) oDsry
/netevcDm( 78: neto

Service Template
ServiceDemo.java

akg o.aaaaadodlfcce

ipr adodapSrie
mot nri.p.evc;
ipr adodcnetItn;
mot nri.otn.net
ipr adodo.Bne;
mot nri.sIidr
ipr adodui.o;
mot nri.tlLg

pbi casSrieeoetnsSrie{
ulc ls evcDm xed evc
sai fnlSrn TG="evcDm"
ttc ia tig A Srieeo;

@vrie
Oerd
pbi IidroBn(netag){
ulc Bne nidItn r0
rtr nl;
eun ul
}

@vrie
Oerd
pbi vi oCet( {
ulc od nrae)
LgdTG "nrae)
o.(A, oCet";
}

@vrie
Oerd
pbi itoSatomn(netitn,itfas it
ulc n ntrCmadItn net n lg, n
satd {
trI)
LgdTG "ntrCmad)
o.(A, oSatomn";
rtr SATSIK;
eun TR_TCY
}

@vrie
Oerd
pbi vi oDsry){
ulc od neto(
LgdTG "neto";
o.(A, oDsry)
}

}

IntentService Template
IntentServiceDemo.java

akg o.aaaaadodlfcce

ipr adodapItnSrie
mot nri.p.netevc;
ipr adodcnetItn;
mot nri.otn.net
ipr adodui.o;
mot nri.tlLg

pbi casItnSrieeoetnsItnSrie{
ulc ls netevcDm xed netevc
sai fnlSrn TG="netevcDm"
ttc ia tig A ItnSrieeo;

pbi ItnSrieeo){
ulc netevcDm(
sprTG;
ue(A)
}

@vrie
Oerd
pbi vi oCet( {
ulc od nrae)
sproCet(;
ue.nrae)
LgdTG "nrae)
o.(A, oCet";
}

@vrie
Oerd
poetdvi oHnlItn(netitn){
rtce od nadenetItn net
LgdTG "nadenetfrato:"+
o.(A, oHnlItn o cin
itn.eAto()
netgtcin);
}

@vrie
Oerd
pbi vi oDsry){
ulc od neto(
sproDsry)
ue.neto(;
LgdTG "neto";
o.(A, oDsry)
}

}

Service Callbacks
oBn(
nid)
Required, but for unbound services, we just return n l .
ul

oCet(
nrae)
Called when service is first created.
oSatomn(
ntrCmad)
Called is called every time service is started.
oDsry)
neto(
Called when service is stopped. It is subsequently destroyed.

IntentService Callbacks
Constructor
It needs to pass the name of this service to its s p r
ue.

oCet(
nrae)
Called when service is first created.
oHnlItn(
nadenet)
This is where the work of the service runs.
oDsry)
neto(
Called when service is stopped. It is subsequently destroyed.

Registering Service
Registering a service that will be called explicitly by its class name

..
.
<evc adodnm=.evcDm"<srie
srie nri:ae"Srieeo>/evc>
..
.

Registering a service that will be called via action

..
.
<evc adodnm=.netevcDm"
srie nri:ae"ItnSrieeo>
<netfle>
itn-itr
<cin
ato
adodnm=mrkn.netato.netevcDm"/
nri:ae"aaaaitn.cinItnSrieeo >
<itn-itr
/netfle>
<srie
/evc>
..
.

Content Provider Overview

Content Providers share content with applications across
application boundaries.
Examples of built-in Content Providers are:
Contacts
MediaStore
Settings and more.

Typical Usage of Content Providers

Content Provider Lifecycle

Content provider is initiated first time it is used via a call to
oCet(.
nrae)

There is no callback for cleaning up after the provider.
When modifying the data (insert/update/delete), open/close
database atomically.
When reading the data, leave database open or else the data will
get garbage collected.

Content Provider Template
ProviderDemo.java

akg o.aaaaadodlfcce

ipr adodcnetCnetrvdr
mot nri.otn.otnPoie;
ipr adodcnetCnetaus
mot nri.otn.otnVle;
ipr adoddtbs.usr
mot nri.aaaeCro;
ipr adodntUi
mot nri.e.r;
ipr adodui.o;
mot nri.tlLg
ipr adodpoie.etnsSse;
mot nri.rvdrStig.ytm

pbi casPoieDm etnsCnetrvdr{
ulc ls rvdreo xed otnPoie
sai fnlSrn TG="rvdreo;
ttc ia tig A PoieDm"

sai fnlSrn ATOIY=
ttc ia tig UHRT
"otn:/o.aaaaadodlfccepoiedm"
cnet/cmmrkn.nri.ieyl.rvdreo;
pbi sai fnlUiCNETUI=UipreATOIY;
ulc ttc ia r OTN_R r.as(UHRT)
sai fnlSrn SNL_EODMM_YE=
ttc ia tig IGERCR_IETP
"n.nri.usrie/n.aaaaadodlfccesau
vdadodcro.tmvdmrkn.nri.ieyl.tts
";
sai fnlSrn MLIL_EOD_IETP =
ttc ia tig UTPERCRSMM_YE
"n.nri.usrdrvdmrkn.nri.ieyl.tts
vdadodcro.i/n.aaaaadodlfccesau"
;

@vrie
Oerd
pbi boenoCet( {
ulc ola nrae)
LgdTG "nrae)
o.(A, oCet";
rtr tu;
eun re
}

@vrie
Oerd
pbi Srn gtyeUiui {
ulc tig eTp(r r)
Srn rt=
tig e
gtotx(.eCneteovr)gtyeSse.OTN_R)
eCnet)gtotnRsle(.eTp(ytmCNETUI;
LgdTG "eTp rtrig "+rt;
o.(A, gtye eunn: e)
rtr rt
eun e;
}

@vrie
Oerd
pbi Uiisr(r ui Cnetausvle){
ulc r netUi r, otnVle aus
LgdTG "netui "+uitSrn()
o.(A, isr r: r.otig);
rtr nl;
eun ul
}

@vrie
Oerd
pbi itudt(r ui Cnetausvle,Srn
ulc n paeUi r, otnVle aus tig
slcin
eeto,
Srn[ slcinrs {
tig] eetoAg)
LgdTG "paeui "+uitSrn()
o.(A, udt r: r.otig);
rtr 0
eun ;
}

@vrie
Oerd
pbi itdlt(r ui Srn slcin Srn[
ulc n eeeUi r, tig eeto, tig]
slcinrs {
eetoAg)
LgdTG "eeeui "+uitSrn()
o.(A, dlt r: r.otig);
rtr 0
eun ;
}

@vrie
Oerd
pbi Cro qeyUiui Srn[ poeto,Srn
ulc usr ur(r r, tig] rjcin tig
slcin
eeto,
Srn[ slcinrs Srn srOdr {
tig] eetoAg, tig otre)
LgdTG "ur wt ui "+uitSrn()
o.(A, qey ih r: r.otig);
rtr nl;
eun ul

Content Provider Callbacks
oCet(
nrae)
Used to initialize this content provider. This method runs on UI thread,
so should be quick. Good place to instantiate database helper, if using
database.
gtye)
eTp(
Returns the mime time for the given uri. Typically, this MIME type will
either be something like
vdadodcro.tmvdmrkn.nri.ieyl.tts
n.nri.usrie/n.aaaaadodlfccesau
for a single item or
vdadodcro.i/n.aaaaadodlfccesau
n.nri.usrdrvdmrkn.nri.ieyl.tts
for multiple items.
isr(
net)
Inserts the values into the provider returning uri that points to the
newly inserted record.
udt(
pae)
Updates records(s) specified by either the uri or
s l c i ns l c i n r scombo. Returns number of records affected.
eeto/ eetoAg

dlt(
eee)
Deletes records(s) specified by either the uri or
s l c i ns l c i n r scombo. Returns number of records affected.
eeto/ eetoAg

qey)
ur(
Queries the provider for the record(s) specified by either uri
or`selection`/s l c i n r sg o p n /h v n combo.
eetoAg/ ruig aig

Registering Content Provider
Registering in Android Manifest file

..
.
<rvdr
poie
adodnm=.rvdreo
nri:ae"PoieDm"

adodatoiis"o.aaaaadodlfccepoied
nri:uhrte=cmmrkn.nri.ieyl.rvdre
m"/
o >
..
.

The authority of this provider must match the uri authority that this
provider is responding to.

Lists and Adapters Overview

Adapters connect potentially large data sets to small views

So, What’s a Fragment?
A fragment is a class implementing a portion of an activity.

A fragment represents a particular operation or interface running
within a larger activity.
Fragments enable more modular activity design, making it easier to
adapt an application to different screen orientations and multiple
screen sizes.
Fragments must be embedded in activities; they cannot run
independent of activities.
Most fragments define their own layout of views that live within
the activity’s view hierarchy.
However, a fragment can implement a behavior that has no
user interface component.

A fragment has its own lifecycle, closely related to the lifecycle of
its host activity.
A fragment can be a static part of an activity, instantiated
automatically during the activity’s creation.
Or, you can create, add, and remove fragments dynamically in an
activity at run-time.

Loaders
Loaders make it easy to load data asynchronously in an activity or
fragment. Loaders have these characteristics:
They are available to every Activity and Fragment.
They provide asynchronous loading of data.
They monitor the source of their data and deliver new results when
the content changes.
They automatically reconnect to the last loader’s cursor when
being recreated after a configuration change. Thus, they don’t need
to re-query their data.

Loaders were introduced in Honeycomb (API 11).

The Android Support Package includes support for loaders. By
including the support package in your application, you can use
loaders even if your application for a m n d V r i nof 4 or later.
iSkeso

Using Loaders in an Application
An application that uses loaders typically includes the following:
An A t v t or F a m n .
ciiy rget

An instance of the L a e M n g r
odraae.

A C r o L a e to load data backed by a C n e t r v d r
usrodr otnPoie.
Alternatively, you can implement your own subclass of L a e or
odr
A y c a k o d rto load data from some other source.
snTsLae

A data source, such as a C n e t r v d r when using a
otnPoie,
CroLae.
usrodr

An implementation for L a e M n g r L a e C l b c s This is
odraae.odralak.
where you create new loader instances and manage your
references to existing loaders.
A way of displaying the loader’s data, such as a
ipeusrdpe.
SmlCroAatr

Availability of Fragments and Loaders
Fragments: Implemented in Honeycomb (3.0) or Later
Fragments were added to the Android API in Honeycomb, API 11.
The primary classes related to fragments are:
adodapFamn
nri.p.rget
The base class for all fragment definitions
adodapFamnMngr
nri.p.rgetaae
The class for interacting with fragment objects inside an activity
adodapFamnTascin
nri.p.rgetrnato
The class for performing an atomic set of fragment operations

Fragments: Implemented in Donut (1.6) or Later
Google provides the Compatibility Package, a Java library that you can
include in an application, implementing support for fragments and
other Honeycomb features (loaders).

Broadcast Receiver Overview

An Intent-based publish-subscribe mechanism.
Great for listening system events such as SMS messages.

Broadcast Receiver Template
ReceiverDemo.java

akg o.aaaaadodlfcce

ipr adodcnetBodateevr
mot nri.otn.racsRcie;
ipr adodcnetCnet
mot nri.otn.otx;
ipr adodcnetItn;
mot nri.otn.net
ipr adodui.o;
mot nri.tlLg

pbi casRcieDm etnsBodateevr{
ulc ls eevreo xed racsRcie
sai fnlSrn TG="eevreo;
ttc ia tig A RcieDm"

@vrie
Oerd
pbi vi oRcieCnetcnet Itn itn){
ulc od neev(otx otx, net net
LgdTG "neev ato:"itn.eAto( )
o.(A, oRcie cin +netgtcin) ;
}

}

Receiver Lifecycle Explained
Sending a broadcast to a receiver

DRcieDm(76) oRcieato:
/eevreo 94: neev cin
mrkn.netato.eevreo
aaaaitn.cinRcieDm

Broadcast Receiver Callbacks
oRcie)
neev(
This is the only method you typically care about for a broadcast
receiver. It is called when this receiver is invoked.

Registering Broadcast Receiver
Registering in Android Manifest file

<eevradodnm=.eevreo>
rcie nri:ae"RcieDm"
<netfle>
itn-itr
<cinadodnm=mrkn.netato.eevreo
ato nri:ae"aaaaitn.cinRcieDm"
/>
<itn-itr
/netfle>
<rcie>
/eevr

Registering programmatically

..
.
@vrie
Oerd
poetdvi oCet(udesvdntnett){
rtce od nraeBnl aeIsacSae
sproCet(aeIsacSae;
ue.nraesvdntnett)
..
.
/ Cet tercie
/ rae h eevr
rcie =nwTmlnRcie(;
eevr e ieieeevr)
fle =nwItnFle(Udtrevc.E_TTSITN
itr e netitr paeSrieNWSAU_NET
);
}

poetdvi oRsm( {
rtce od neue)
sproRsm(;
ue.neue)
sprrgseRcie(eevr fle,
ue.eitreevrrcie, itr
"o.aaaaymaSN_IEIENTFCTOS,nl)
cmmrkn.ab.EDTMLN_OIIAIN" ul;
}

@vrie
Oerd
poetdvi oPue){
rtce od nas(
sproPue)
ue.nas(;
urgseRcie(eevr;
neitreevrrcie)
}
..
.

App Widgets Overview
App widgets are miniature views that can live in other apps, such
as Home app.
They are a special implementation of Broadcast Receivers.

Declaring an App Widget
Widgets are essentially Broadcast Receivers
Yamba App Widget registration in AndroidManifest.xml

<eevr
rcie
adodnm=.abWde"
nri:ae"Ymaigt
adodlbl"srn/p_ae >
nri:ae=@tigapnm"
<netfle>
itn-itr
<cin
ato
adodnm=cmmrkn.racs.E_TTS /
nri:ae"o.aaaabodatNWSAU" >
<itn-itr
/netfle>

<netfle>
itn-itr
<cin
ato
adodnm=adodapigtato.PWDE_PAE /
nri:ae"nri.pwde.cinAPIGTUDT" >
<itn-itr
/netfle>
<eadt
mt-aa
adodnm=adodapigtpoie"
nri:ae"nri.pwde.rvdr
adodrsuc=@m/igt /
nri:eore"xlwde" >
<rcie>
/eevr

Specifying Meta Data

Meta data specifies the default size of the widget, plus the update
period.
Yamba Widget meta data

<xlvrin"."ecdn=uf8?
?m eso=10 noig"t-">
<pwde-rvdr
apigtpoie
xlsadod"tp/shmsadodcmakrsadod
mn:nri=ht:/cea.nri.o/p/e/nri"
adodmnegt"2p
nri:iHih=7d"
adodmnit=24p
nri:iWdh"9d"
adodudtProMli=100 >
nri:paeeidils"00"
<apigtpoie>
/pwde-rvdr

Implementing App Widget
pcaecmmrkn.nri.ab;
akg o.aaaaadodyma

..
.

pbi casYmaigtetnsApigtrvdr{
ulc ls abWde xed pWdePoie
piaesai fnlSrn TG=
rvt ttc ia tig A
Ymaigtcasgtipeae)
abWde.ls.eSmlNm(;

@vrie
Oerd
pbi vi oRcieCnetcnet Itn itn)
ulc od neev(otx otx, net net
{
sproRciecnet itn)
ue.neev(otx, net;
if
(netgtcin)eul(abApNWSAU_RACS) {
itn.eAto(.qasYmap.E_TTSBODAT)
Apigtaae apigtaae =
pWdeMngr pWdeMngr
Apigtaae
pWdeMngr
.eIsac(otx)
gtntnecnet;
ti.npaecnet
hsoUdt(otx,
apigtaae,apigtaae
pWdeMngr pWdeMngr
.eApigtd(e
gtpWdeIsnw
Cmoetaecnet
opnnNm(otx,

Ymaigtcas);
abWde.ls))
LgdTG "neevd)
o.(A, oRcie";
}
}

@vrie
Oerd
pbi vi oUdt(otx cnet Apigtaae
ulc od npaeCnet otx, pWdeMngr

apigtaae,
pWdeMngr
it]apigtd){
n[ pWdeIs
sproUdt(otx,apigtaae,
ue.npaecnet pWdeMngr
apigtd)
pWdeIs;

/ Gttedt
/ e h aa
Cro cro =
usr usr
cnetgtotnRsle(.ur(
otx.eCneteovr)qey
SauPoie.OTN_R,
ttsrvdrCNETUI
nl,nl,nl,
ul ul ul
SauDt.OTB)
ttsaaSR_Y;

/ D w hv aydt?
/ o e ae n aa
i (usr=ul& cro.oeois(){
f cro!nl & usrmvTFrt)
Srn ue =cro.eSrn(usr
tig sr usrgttigcro

.eClmIdxSauDt._SR)
gtounne(ttsaaCUE);
Srn tx =cro.eSrn(usr
tig et usrgttigcro

.eClmIdxSauDt._ET)
gtounne(ttsaaCTX);

/ Lo tr altewde isacs
/ op hu l h igt ntne
fr(n apigtd:apigtd){
o it pWdeI pWdeIs
RmtVesves=nw
eoeiw iw e
RmtVescnetgtakgNm(,
eoeiw(otx.ePcaeae)
Rlyu.o)
.aotrw;

vesstetiwetRi.etue,ue)
iw.eTxVeTx(.dtx_sr sr;

vesstetiwetRi.ettx,tx)
iw.eTxVeTx(.dtx_et et;

vesstetiwetRi.etcetdt ")
iw.eTxVeTx(.dtx_raeA, ";

apigtaae.paepWde(pWdeI,ves;
pWdeMngrudtApigtapigtd iw)
}

}
LgdTG "npae";
o.(A, oUdtd)
}

}

Architecting Android Apps Summary
This module was an introduction to main components that make up an
app. By now, you should know of activities, services, providers and
receivers as well as intents and other major components of an app.

Architecting Android Apps Summary
Thank you!
Marko Gargenta & Marakana Team
@MarkoGargenta
Special thanks to Ken Jones as well as the rest of Marakana team for
research related to Fragments, Loaders, and many other new features of
ICS.
Slides & video of this presentation is available at Marakana.com
Yamba source code is available at https://github.com/marakana/yamba
(c) Marakana.com

Architecting Android Apps: Marko Gargenta

Architecting Android Apps: Marko Gargenta

More Related Content

What's hot (20)

Viewers also liked (16)

Similar to Architecting Android Apps: Marko Gargenta (20)

Recently uploaded (20)

Architecting Android Apps: Marko Gargenta