Activities

a n d F r a g m e n t s

1/labus activities, Using Intents, Fragments,

ith
F ra gm en ts an d In te nt s in Android Working w
fng Activities,
bject to In vo ke B ui lt - in Application
!ng the Intent O

rJntents
1 Activity Lifecycle
id
2 Fragments in A nd ro
en t
3 Life Cycle o f F ra gm
t
4 Replacing F ra gm en
5 Intent
r A ct iv ity
6 Intent to S ta rt an ot he
In te nt
7 lmplicir an d E xp lic it
ic e (AVD)
8 Android Virtual D ev
P ro ce ss
9 Mapping A pp lic at io n to
w er s
10 Short Questions an d A ns
11 Multiple Choice Q ue st io ns
 ~~~~
"!!'bile Applicatio ~~~t_ _ _ _~ _. = .: __
2 2
n [)evefopmen

Ell Activity Lifecycle

_ Activities and F
-- -- -- -- ~ ~~
~
-
. ..
.
. .on com pns e one or mor e acti vitie s. Bec aus e of the mob ile
• Applicati . f an acti vity is gov ern ed by a set of stat es at\d lJ1
experience the ope ratio n o Oike ...
e) called the lifecycle. a fini~
~~~ chin
if the user rece ives a pho ne call or swi tch
a) Crashing es to ano ther app Wh;,
usin g you r app . ute
4

b) Con sum ing valu able syst em reso urce s whe

n the use r is not acti vely usin g it
c) Los ing the user 's prog ress if they leav
e you r app and retu rn to it at a later
time .
d) Cra shin g or losi ng the use r's pro gres
s whe n the scre en rota tes between
land scap e and por trai t orie ntat ion.
• To nav igat e tran sitio ns betw een stag es
of the acti vity lifec ycle , the Act ivity class
prov ides a core set of six call back s: onC reat
e(), onS tart (), onR esu meQ , onPauseo,
onStop(), and onD estr oy() .
• The syst em invo kes eac h of thes e call bac
ks as an acti vity ente rs a new stat e.
1. onCreate()

• This call back mus t be imp lem ente d, whi

ch fire s whe n the sys tem crea tes your
activity. You r imp lem enta tion sho uld init
ializ e the esse ntia l com pon ents of your
activity: For exa mpl e, you r app sho uld crea
te view s and bin d dat a to lists here.
Mos t imp orta ntly , this is whe re you mu
st call setC ont entV iew () to defi ne the
layo ut for the acti vity 's use r inte rfac e.
• Wh en onC reat e() fini shes , the nex t call bac
k is alw ays onS tart ().
2. onStart()

• As onC reat e() exit s, the acti vity ente rs

the Star ted stat e, and the acti vity becomes
visible to the use r. Thi s call bac k con tain
s wha t amo unt s to the acti vity 's final
p repa rati ons for com ing to the fore gro und
and bec omi ng inte ract ive.
3. onR esu me( )
• The sy stem invo kes this call bac k just
befo re the acti vity star ts inte ract ing with
the
use r. At this poin t, the acti vity is at the top
of
the acti vity stac k, and cap ture s all
use r inp ut. Mo st of an app 's core func tion
ality is imp lem ente d in the onR esumeO
met hod .
• The onP aus e() call bac k alw ays foll ows onR
esum e{).

TECHNICAL PUBLICATIONS® - An up thrus

t for knowledge
 Activities ana r,a-::,-· ·

2-3
/icstion Development
p;teAPP
o Paused
paLlseO f cus and enters a
of1 alls onPause() when the activity loses o B k or Recents
~~c ~s~ ~
, 'fhe ThiS state occurs when, for example, the user . . it technically means
state. When the system calls onPause() for your activ1~' . . that the user
button. t ft is an indication
. ·ty is still partially visible, but mos O en d Resumed
your acnv1 ti. ·ty and the activity will soon enter the Stoppe or
. ving the ac v1 ,
is 1ea
state. th UI if the user is
tivity in the Paused state may continue to update e h . g a
An ac . . . lude one s owm
' ting the UI to update. Examples of such an activity me . ..
expec . E .. f such activities 1ose
1
. an· on map screen or a media player playing. ven
nav1g
S th
e user expects their UI to continue updating. k
f~,
. . d ta make networ
, You should not use onPause() to save application or user a ,
calls, or execute database transactions.
, Once onPause() finishes executing, the next callback is either onStop() or
onResume(), depending on what happens after the activity enters the Paused state .

. onStop()
, The system calls onStop() when the activity is no longer visible to the user. This
may happen because the activity is being destroyed, a new activity is starting, or
an existing activity is entering a Resumed state and is covering the stopped
activity. In all of these cases, the stopped activity is no longer visible at all.

• The next callback that the system calls is either onRestart(), if the activity 18
coming back to interact with the user, or by onDestroy() if this activity 18
completely terminating.
•onD&stroy()

• The system · k this

mvo es callback before an activity is destroyed.
• This callback 18· th final nD
. e one that the activity recei·ve
lihplemented to ens s. o estroy() is usually
activity ure that all of an activity's resources are released when the
'or the process containing it, is destroyed.
 Mcuv1c1es and F
2 - 4 - - - - - - - - - - - - - rageme,11~
. oeve/opment
Mobile Appficst1on

on Create()

onStart()

on Resume()
user navigates
to the activity

Activity
App process running
killed

Another activity comes

into the foreground User returns
to the activity
I
Apps with higher priority onP{use()
need memory
The activity is
no longer visible User navigates
to the activity

onStop()

The activity is finishing or

being destroyed by the system

on Destroy()

Activity
shutdown

Fig. 2.1.1
fl1 Fragments in Android
• Fragment class in Android is used to build dynamic User Interfaces. Fragmenl
should be used within the Activity.
• A greatest advantage of fragments is that it simplifies the task of creating UI for
multip le screen sizes. A activity can contain any number of fragments.
• A Fragment rep resents a behavior or a portion of user interface in a
FragmentActivity.
• Multiple fragments can be combined in a single activity to build a multi-pane VI
and reuse a fragment in multiple activities.

TECHNICAL PUBLICA T/ONs® - An up thrust for knowledge

 Activities ana "Cll:f"'' · · - ·
2-5
. ffon oeveJopment
APp1,cs •
~ . ·ty which has its
ent can be considered as a modular section of an actiVl ' ve
A fragtn . . d hich ou can add or remo
• lifecycle, receives its own input events, an w Y in
own f k " b ti. .ty" that you can reuse
. the activity is running (sort o Ii e a su ac v1
\\ThiJe "
different activities). .
ust always be hosted in an activity and the fragment's lifecycle ~
A fragtnent m · · ty is
' Jirec!1 affected by the host activity's lifecycle. For example, when the actiVl
__I
paUSt'V-1
so are all fragments in it, and when the activity is destroyed, so are all
_
fragments.
e an activity is running (it is in the resumed lifecycle state), you can
However, Whil
• anipulate each fragment independently, such as add or remove them. When you
~ rm such a fragment transaction, you can also add it to a back stack that's
managed by the activity-each [Link] stack entry in the activity is a record of the
fragment transaction that occurred.
, The back stack allows the user to reverse a fragment transaction (navigate
bacbvards), by pressing the Back button.
• When you add a fragment as a part of your activity layout, it lives in a
ViewGroup inside the activity's view hierarchy and the fragment defines its own
view layout. You can insert a fragment into your activity layout by declaring the
fragment in the activity's layout file, as a <fragment> element, or from your
application code by adding it to an existing ViewGroup.

Importance of Fragments

• There are many use cases for fragments but the most common use cases include :
1
~=ing View and Logic Components - Fragments enable re-use of parts of
Y screen mcluding views and event logic over and over m· cliff
erent ways
across many dispara te [Link]"es. For example, using the same list
dilie~ t da across
en ta sources within an app.

2. Tablet Support - Often 'thin

substantial} . wi apps, the tablet version of an activity has a
y different layout from the phone version which is diff
the 1V ve · erent from
rsion. Fragments enable devic pecifi. · ••
elements hi1e e-s c activities to reuse shared
w also having differences.
3. Screen O . .
nentation - Often within h .
a SUbstantiall . apps, t e portrait version of an activity h
b th y different layout from the landsc . as
o Orientations t ape version. Fragments enabl
'----- o reuse shared elements while also having cliff e
~ erences.
 . eve/opment
Mobile Application D
. .
ragments . ·ty which has its own lifecycle. It
-.ee l ose of F f an AdiV l ,
fSSil purp 1 section o . n,inning and can also be reusedc¾.
t is a modu ar . Activity is
• A fragtnen oved while an ~
dded or rein
be a . ·tt·es
.1:a nt act1v1 · t ou have to subc lass the Frag ment
.
class. ~o
wuere T eate a Fragmen y trUctor beca use And roid will oftenu
und: 0 er 011ment cons '
• Backgt0 'd a public no-are,-- d d (-> state resto re).
have to prov1 e t class when nee e
re-mstantiate a Fragtnen
Purpose of a Fragment ent is to supp ort a more dyn ~c UI (table~,
ain purpo se of a Fragm f U1 comp onen ts a lot easier.
• The m ake the reuse o
smartphones) and also tom . U1 as an invis ible worker for the
an also exist witho ut its own
• A Fragment C
Activity. . . . . . Whe n the Acti vity is paused, so
• A Fragment is closely tied to the Ac~~1ty. it ~s :~ ed so are
are all fragments in it; When the Activity is es y , all fragments in it.

·~
fJjj communication between Fragments and Activity
t 1. [Link] method can return a FragmentActivity object. This
~ object is just the Fragment belongs Activity.
2. [Link]() meth
r od will retur n a
[Link] Manager instance.
I 3. [Link]() meth od can
retrie ve the desired
f Fragment object with specified id.
r 4. Call [Link]().findViewByld() meth od
to get the view controls in
that Fragment.
5. Then you can change the view control's prop erty and add even
t listener.
flJ Life Cycle of Fragment

• Android Fragment is the part of activity, it is also know n

as sub-activity. Ther j
can be more than one fragment in an activity. Fragments repre
sent mult iple screen
inside one activity.
• Android fragment lifecycle is affected by activity lifecycle
r because fragments are
included in activity.

• Each fragment has its own life cycle methods that is affec
ted by activity life cycle
because fragments are embedded in activity.

TECHNICAL PUBLICATIONS® - An up thrust for knowledge

. ;on Development 2-7 Activities and Fragemenh
 ()BVIJ/OP
,r,ent
,.rcsti0f1
Mobi/8 APY-'

onCreatView()

onActlvltyCreated()

onStsrt()

onResume()

Fragment Is active

user navigates The fragment is

backword or added to the back
fragment is stack them
removed/replaced removed/replaced

f onPause()

The fragment

t onStop()
returns to the
layout back
stack
r
onDestroyview()

on Destroy()

onDetach()

Fragment is destroyed

- - - - - - - - - -Fig-. -
2.3.1 Android fragment llfe cycle
----------- __ -/
TECHNICAL PUBLICATIONS® - An up
------
thrust for knowledge
 /l;-l1w
~!f APr

la cing Fragment
ReP
.
[Link] g one , bu t requi,res
rocedure to. replace a fragment is similar to the
n,e P
' ceO method instead of addO.
rep 1a
men t tran sact ions is per fo~ ed, such as repl ace or remove one , it's ~fte n
' W}le n frag
rd and "undo" the change.
appropriate to allow the user to navigate backwa
· cti' ons , you
t transa
allow the use r to navigate backward through the fragmen
, To FragmmtTransaction.
must call addToBackStack{) before you commit the
add the transaction to the back stack,
, When you remove or replace a fragment and
the fragment that is removed is stopped (not
destroyed) . If the user navigates back
not add the transaction to the back
to restore the fragment, it restarts. lf you do
oved or replaced.
stack, then the fragment is destroyed when rem
:
Example of replacing one fragment with ano ther
KOTLINJAVA
clfy:1ng the article tt should show
Create fragment and give .it an argument spe
, ewFragm~nt :::! Art icle Fra gme ntO
,' :-cije args ;; Bundle()
gs:p titJn t(Ar ticle Frag men t~G_POSITION ,
position)
,:[Link]:guments = args
. ',/ ·. ·, ·, •: •:.-, ·.

[Link] ly {
:: ~~sa~ion 7 sup por tFra gme ntM ana ger .beginTran
frag men t,
:;~;~~Hl~9~ ir~,t~yer
is in the frag men t_con tain er view wit h this
back stack so the user can navigate bac k
:/2'~~ ~~§. the ttan.~action to the new
~J)la9e([Link]µ.ent Fra gm ent)
con tain er,
::;.~t··/~. ·iB~
0 t~i<P-~>1•: · . . , .>··;>ti
rrcr•·· . •.•·•· •· . : : f i:>FP

, 1 a 111ll . ...... ... . . .

• The addToBackStack() method takes an option
Itillil?/t;;CM01"'.\;b,· . ::::c·J;t,::, ,;; {! cf .
al string parameter that specifies a
isn't needed unless you plan to
unique name for the transaction. The name
perform advanced fragment operations using the
[Link] APls.
Intent
th. Android applications. This
• And roi·ct application components can connect to O er
an Intent obJect.
connectio• n is based on a task description represented by
lication components to request
• Inte asynchronous messages which allo w app
nts are
functionality from other Android components. d intents are mainly useful to
• Inte . an
nts are the objects of android. Intent type
. gs.
Perform f [Link] thin
® thrust for 1<now/edge
TECHNICAL PUBLICATIONS - An up
 , ,v.,.,,11,c,s and
Frag
ems,,,
\

. ton oeve/oPment onents from the same app1·ications '

•th comp
th applications. For examp1e, an acti as. w(
. APP1,cs 1
Mobile mteract w1
w ou to . ted by o er V1~c
• Intents allo :ents contr1bu . a icture.
as with [Link] activity for [Link] .,.--~ ---•,W•''•""'•'•'"':'·'···---···•·W••:-·'•,','N.'.',•'•""'·····• •,•··"•M,......,.,...,,..w.,•:· ,.,.,..,....,,. .,_,w,..... , ..-.v.,,,,,,,,,N,,.,.,,,.,,.~
~
vtetll "'"""·--•""~"''''"'·'''' ' .' ' jJ. ' , •.
tart an e~ ..,. . ,,..""'' ""':· · ·· · · ·. Desctipuon ·
. .,. ,. w:"~~~;~1i~i~,,11r· ·~-': ··.· .- · . .·......... ... . ...·. . . . . . .:. .... . . ... .' . . ·. . . . . .:.}. . . . .- .:·. . . ... . . . . .... .. . . ... .. .. .
ifil":_,;~,~-· ]::." ,. ' '
'§:~=$..~:::~,
I. ' '}·~t~ :~~~:l ~t\~~t!t~;r--·•·": ,. ·":"'.·•'""·•:•":""'"":"t~ternet ·object to t¢mA:dtivitv{J m~tb~d :~e .can Start
,,~,,--• ' '?$:'~

i """''''' "'" 11'/\1}\::,,\,t> ~ ',, ,,, ' ' Bv nassmg, an J;ll, • ~ft· ';:A'-"fi·11r.1·hi :.l'h nerfotm .reqmr&t thiiias·. a
;,...Startir~fai).~
,,,.,,, ac~rt;t
',.-,,.;w.,~· •., ·>·, ·. itew
~.J\< • ·ru ,,.,.
r r,:AcfiVJ.v, ·eXlS™=~" a ... , , tJ,:: :.~v, r:=, • .. . · o ·
V+-• . . . ___ · l'? ...... :.... ··--· ._....... -· .,...:. •:... -·:··......-...,-:.,.· .. ,- ...... ,,,. , w, : ,. ..,..;......,_, .......... .

/ -· - .:1:!:~~:,:\\.~)-~::-.. ~-;.:~- -:- - - - :. . :- - :- - - - - -· - - - - - - ;~~~et·~ffi~ct to startS~fflc,ei>·~ethaa we -t:~start

~- ,.......:. . . . .,_., . , ~i; ··-. , ,i By pa~g an. · .· ea msttuetitm$ .to· an ·existing Service. a
: Statfi11g ~ se new ~~~...!~. ~~~ . ~I:~ ... -:. . .. . . . .. . :.: . . .:. .:•:. . . . ,: •:'·' . . . . . .:. . . . . . .:. . ,. .:. . . , ,.. ·
·, -· · 1• •

i ' ' .'... '' .,, ,,..'" . . ,. . . . ...... . . . ...:•·•~ "''.. an Intemet .·ohmct ·to sendS,tC>:[Link] ~ethod we can
, INliverjpga·[Link]~~e : . By .P~ssmg · to t;ffieitagp ·[Link].c~vers. . · , ·
: '. ' : [Link].~~»~~--~~!~~~~.:...,. . . ,,..,.,..,. ..,,.,... ,. ••❖ ❖u''- ,:.:.:.,..•❖ •·❖n.<❖SW.<<«•W,WM'n❖ ,,,,,...,,,,.,,,,..,,.,.,Hu,,.,_
••,,, . ,....... , •••, w•~-'· ·· e
~
~~-H••,.,~W"'"~·--~ b.. ,iect which is used to request an action from another a~~ f,
.,,,...,..,,.."""'"'"'~---..~-----·•·--'· . •

• Intent IS a messaging o J • •
component such as activities, services, broadcast re~e1~ers and content provider!.
Your code can send them to the Android system defmmg the components you ar1
targeting. For example, via the startActivity() method you can define that ilii
intent should be used to start an activity.
• An intent can contain data via a Bundle. This data can be used by the receivini
component.
• In Android the reuse of other application components is a concept known as task
An application can access other Android components to achieve a task. For
example, from a component of your application you can trigger another
component in the Android system, which manages photos, even if this componenl
is not part of your application. In this component you select a photo and return to
your application to use the selected photo.

fD Intent to Start Another Activity

• An Intent is an object that provides runtime binding between separa~
components, such as two activities.
The Intent
• wid . represents an app 's intent
. to do something. An intent can be used for 2
•
e v anety of tasks , one of these task is use of . intent to start another activity.
e XTRA_MESSAGE constant and the sendMessage() code ft.
• In MainActivity add th E
as shown : ' ~

00~1; Val
· EXTRA
· • _MESS
. .. . .AGE. = [Link]'r»_
II •
.. ' . •-.::,;

,clas.s Mai~cti'Vity : AppCoJJlpatActivity() { •

ovemde
.
-'-•- c ·
uJ.u on rttate(•avedlnst
·.S . · .·
su;[Link](savedinet . .. S ance tate: Bundle?) { . •
e~tContent . . . anoe tate) .
· · · View(JllJcY9ut •.aattvity-~l . .. . .
-------~TE;C;H;N,;C~Al~P;U~B~ll-; C~A~Tl: ON~S]®~An-:---~==:=:::_:_:~__.-/ - up thrust for knowledge
 . (ion Development 2- 11 Activities snd Fragements
;teAPP/fcS

Here's what's going on in sendMessage():

• The Intent constructor takes two parame ters, a Context and a Class.
• The Context parame ter is used first because the Activity class is a subclass of
Context.
• The Class parame ter of the app component, to which the system delivers the
Intent, is, in this case, the activity to start.
• The putExtra() method adds the value of EditText to the intent. An Intent can
carry data types as key-value pairs called extras.
• Your key is a public constan t EXTRA_MESSAGE because the next activity uses the
key to retrieve the text value. It's a good practice to define keys for intent extras
~ith your app's package name as a prefix. This ensures that the keys are unique,
incase your app interacts with other apps.
• The startActivity() method starts an instance of the DisplayMessageActivity that's
specified by the Intent. Then class can be created.

lrnplicit and Explicit Intent

• An irnplicit Intent does not name a specific component. It declares a general action
to perform. The action specifies the thing that the app wants to do.
: :ackground : The system is looking for an appropr iate component to start: .
lllultiple components are compatible with the action, the system shows a dialog
so the
user can pick which app to use.

TECHNICAL PUBLICATIONS® • An up thro sf for knowledge

 Activities and F
rag& r
., Application Deve/opment d · ha
Mob1 e
onent av a ilable on th e ev1ce t t can han.. 1 ,
· no ap riate comp ' '-lle
• If there is pro p . dia tel y ·
ill crash 1trune .
action, your app w wants
to trigger a p
ho ne call, it only has to" spectfy

:- ... .-.·.. .•...:: ... :,: ...::...-.,:-.-.•,:.:-.-.-\./,:-::;.;-:,:-.-:..

·

··········-.··•.···:: •,•···-••.',' •• ····

Explicit Intent
• An explicit Intent [Link] the co mp on ent by the fully-qualified class name
es on en t in th e ow n ap p.
. the common case to sta rt
start. This is a co mp

Example :
Intent startlntent = new Inten ot he rA cti vi ty .cl a
t(myContext, An
fl1 Android Virtual Device (AVD)
r • An Android Virtual De
vice (AVD) 1s . nfi ti
characteristics of an Android a co gu ra on th at defines ~t
phone, tablet, W ea r OS, And .d TV or Automou
y OS device that you want to sim ro1 ,
ulate in the An dr oi d Em ul
ato r. .
• An Android Virtual Devic
e (AVD) is a device co nf ig th
Android emulator. It works wi ur ati on th at is run wi t,
th the em ula tor to pr ov id e
environment in which to instal a vi rtu al device-spec:
l an d ru n An dr oid ap ps .
• An AVD contains a hardw
are profile, sy ste m im ag e,
properties. sto ra ge are a, skin, and o:1'

• The avdmanager is a comm

and line tool tha t all ow s
Android Virtual Devices (AVD yo u to cre ate an d Jlla!l'.
s) from the co mm an d line.
the characteristic An AVD lets you deI•
s of an Android ha nd se t, W
that you want to simulate in ea r OS wa tch , or An dr oi d
the An dr oid Em ula tor . TV de'
• If you're using Andro id Stu
dio, then yo u do no t ne ed
ins tead create an d manage A to us e this tool an d yot1 :
VDs from the IDE.
• Th e avdmanager tool
is provided in the An dr oid
hig he r) and i.s loc ate d in an SOK Tools pa ck ag e (25 .3.0
dro id_sd k/ :
to ol s/b in / .
Syntax

avdmanager [global op tions l

co mm an d lco mm an d op tions
]

TECHNICAL PUBLICA TIONs

® - An up thrust for knowle
dge
 2-1 3 Activities and Frtl(Jemen~
. tion oeve/opment
8
ite APP11c
·ng Application to Process
r,1aPP 1
in the Java pro gra mm ing language.
, Android applications are prim aril y wri tten
And roid specific configuration files
. development the dev elo per creates the . language.
. m
g es the appIicati·on logic
ourtnwrit
• and . the Java pro gra mn ung

ADT or the And roid stud io tool s con ver t these app lica tion files, tran spa ren tly
The
' to the user, into an And roid application.
in thei r IDE, the who le And roid
• When developers trigger the dep loy men t
and star ted.
application is compiled, pac kag ed, dep loy ed
nversion Process from Source Code to And
roid Application
s files by the Java compiler.
, The Java source files are con ver ted to Java clas
whi ch con ver ts Jav a class files into a
• The Android SOK contains a tool called dx
app lica tion are pla ced in this .dex
.dex (Dalvik Executable) file. All class files of the
file.
• During this conversion process red und
ant info rma tion in the class files are
e Sb'ing is fou nd in diff eren t class
optimized in the .dex [Link] example, if the sam
of this Sb'ing.
files, the .dex file contains only one reference
in size than the cor resp ond ing class
• These .dex files are therefore mu ch smaller
files.
roid project, e.g., the ima ges and XM L
• The .dex file and the resources of an And
e) file. The pro gra m aapt (An dro id
files, are packed into an .apk (Android packag
Asset Packaging Tool) performs this step.
ry data to run the And roid application
• The resulting .apk file contains all necessa
and can be deployed to an And roid device
via the adb tool.

droid SOK Features

• Im
1 N0
P_ortant features of And roid SOK are as under.
or release app rov al processes .
· licensing, distributions or dev elop men t fees
2. Fu11 mul .
timedia har dwa re control.
3. APis f . ter and the compass .
or using sensor har dwa re including accelerome
4 .
. APis for l
OCa tion based services.
5
· Android In
6. Sha ter-Process Communication (IPC).
7 red data storage .
. Backgro
8. Ji und applications and processes.
Oll1.e sere .
9. ~ en widgets, live folders.
WebIGt-based web browser.

thrust for knowledge

TECHNICAL PUBLICATIONS® - An up
 Mobile Application Development 2-14 Activities and Fragements

10. GSM, EDGE and 3G networks for telephony and data transfer.
11. The Android SDK includes development tools which helps compile and debug any
app.
\ 12. Android emulator shows how app will look and behaviour on a real Android
device.