This document discusses passing data between activities in Android applications. It provides an overview of different data passing methods, including using global variables stored in the application object, storing data in a separate data layer like a database, and sending data in bundles via intents. It also covers the Android activity lifecycle and how activities are stacked. The document includes code snippets and diagrams to illustrate concepts. It concludes with demos of passing data between activities using global variables and intents.

1. HIT3328 / HIT8328 Software Development for
Mobile Devices
Dr. Rajesh Vasa, 2011
Twitter: @rvasa
Blog: http://rvasa.blogspot.com
1
Lecture 04
Complex
Interactions

2. R. Vasa, 20112
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (using Global Variables)
•Application Manifest File
•Passing Data Demo (using Intents)
•Controlling Input Type

3. R. Vasa, 20113
Android Device User
Interaction
Menu
HomeBack

4. R. Vasa, 20114
Android App. is made of
Activities
Activity
View Group
Views
(Layout)

5. R. Vasa, 20115
User Interface (generally) Built
in XMLActivity
View Group
(Layout)
Activity Class (Java)
Layout Definition
(main.xml)
PresentatioPresentatio
nn
FunctionaliFunctionali
tyty

6. R. Vasa, 20116
The Android Way - Convention not
Config.
•Source code (src)
•Generated code (gen)
•Resources (res)
•Images (@drawable)
•Layout of app (layout)
•Constants/Strings (@strings)
Conventions to Follow

7. R. Vasa, 20117
Portrait and Landscape Layouts
Conventions to Follow

8. R. Vasa, 20118
Provide Resources @Multiple
Resolutions
High
Low
Medium
Conventions to Follow

9. R. Vasa, 20119
View Identifiers
@+id TAG creates new identifiers
Conventions to Follow

10. R. Vasa, 201110
UI Interaction Handling Pattern
•Component.setOn......Listener ( handler
)
•E.g. button.setOnClickListener
•Handler is an anonymous inner class
•On...Listener handler = new
On....Listener() {}

11. R. Vasa, 201111
Android Activity Life Cycle
onCreate is called
when Activity Starts
Activity is
re-started
when
orientatio
n
changes

12. R. Vasa, 201112
We Retrieve State On Creation
State retrieval
done here
onSaveInstanceState(
) is called from this
state
(Save Saved here)

13. R. Vasa, 201113
Bundle stores simple state
information
BundleBundle
putString(key, value)
putDouble(key, value)
putInt(key, value)
putStringArray(k
ey, value[])
It is a Key, Value store system
(like a Hash Table or a Hash Map)
Code Snippet:
state.putString("inputTemperature", inputTemp);
Code Snippet:
state.putString("inputTemperature", inputTemp);

14. R. Vasa, 201114
Working with Resources
off.png
Layout XML File
Via Java Code
on.png

15. R. Vasa, 201115
Short Problem 1 - Passing Data
•Context: In Android -- Apps are made of
Activities. So, each Screen is a “new”
Activity
• We want to pass data between Activities.
• But, Activity construction is managed by the
Dalvik runtime. That is, cannot pass data into
constructor.
•What would you prefer to do?
• Store shared data in global variables available to
ALL Activities.
• Move all data to a separate data layer.
• Send primitive data bundles between

16. R. Vasa, 201116
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (using Global Variables)
•Passing Data Demo (using Intents)
•Controlling Input Type

17. R. Vasa, 201117
Wiring up Activities -- Typical
Use Case
Select
Back
Contact List Activity Contact Details

18. R. Vasa, 201118
Wiring up Activities -- Typical
Use Case
Select
Contact List Activity Contact Details
We re-use this
activity with
different data
Select

19. R. Vasa, 201119
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing options
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (using Global Variables)
•Passing Data Demo (using Intents)

20. R. Vasa, 201120
Data Passing Option - Global
Variables
•We can use Global Variables ... but,
•Widely accepted as a “risky” choice
•A few global variables are used in many
large systems (e.g. Linux Kernel Source
Code)
•Risk manageable in ‘small’ programs
•Good thread @ StackOverflow
http://goo.gl/EouH3
•Constant values as globals is ok (e.g.
R.java)
•Key Issue (to manage): How many objects

21. R. Vasa, 201121
Data Passing Option - Data
Layer
•We can store all data in a DBMS and access
it via a “data layer”
•Good idea when dealing with large /
complex blocks of data
•Overkill if we only need to store a few values
•The data store can be “in-memory”,
“on-disk”, and/or “on remote server”

22. R. Vasa, 201122
Data Passing Option - Bundles
•We can put data into a bundle and pass
this across using a “messaging
framework”
•Simple (once you understand the messaging
framework architecture)
•Persistence is not managed (like DBMS)

23. R. Vasa, 201123
Data Passing Option - iOS
Only!!
•You can pass data directly to methods in
another screen (UIViewController)
•UIViewController is approx. similar to Activity
•This option is not possible in Android -- this
was a “design intent” (design side-effect?)

24. R. Vasa, 201124
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (using Global Variables)
•Passing Data Demo (using Intents)
•Controlling Input Type

25. R. Vasa, 201125
iOS Apps. are directly managed
by O/S
UIAppDelegateUIAppDelegate
UIViewController-UIViewController-
AA
UIViewController-UIViewController-
BB
UIViewController-UIViewController-
CC
UIAppDelegate has Life
CycleView Controllers are
managed by the App
internally
Image Source: Apple Inc.
Life Cycle => Managed by Operating
System

26. R. Vasa, 201126
Android Activities are Managed by
O/S
Activity-AActivity-A
Activity-CActivity-C
Activity-BActivity-B
ApplicatiApplicati
onon Activities have
a parent
application
Activity has Life CycleApplication is NOT
managed directly by
the O/SLife Cycle => Managed by Operating
System

27. R. Vasa, 201127
A Key Design Different (iOS Vs
Android)
Activity-AActivity-A
Activity-CActivity-C
Activity-BActivity-B
UIAppDelegateUIAppDelegate
UIViewController-UIViewController-
AA
UIViewController-UIViewController-
BB
UIViewController-UIViewController-
CC
ApplicatiApplicati
onon
UIAppDelegate has Life
Cycle
Activities have
a parent
application
Activity has Life CycleApplication is NOT
managed directly by
the O/SLife Cycle => Managed by Operating
System
View Controllers are
managed by the App
internally

28. R. Vasa, 201128
Activity Life Cycle Design
Choice....
•Android developers decided to give Activity
a life cycle (rather than the application)
•This makes each Activity similar to a
separate program
•Hence, data passing is restricted to:
•Global Variables (stored in Application
object)
•Data bundles passed via async. messages
•Data stored externally in files or DBMS

29. R. Vasa, 201129
Short Problem 2 - Activity Design
Choice
•Unlike iOS ViewControllers, Activities have
been modelled to be (almost) like
independent programs
•What is the likely rationale for such a
choice?
•What would be the benefits?

30. R. Vasa, 201130
Only One Activity is
Active/Running
•Only one Activity can
be in the ‘foreground’
•When Activity-A calls
Activity-B
•Activity-B will be visible
to the user
(foreground)
•Activity-A is paused
(background)

31. R. Vasa, 201131
Activities are Stacked in
Android
•All created activities are placed on a Stack
•Activities ‘popped’ when ‘Back Button’ is
pressed
Activity-AActivity-A
Foreground/Acti
ve
If only one activity
is on the Activity
Stack then “back”
button exits it

32. R. Vasa, 201132
Activities are Stacked in
Android
•All current activities are placed on a Stack
•Newly started activities come into
foreground
Activity-AActivity-A
Activity-BActivity-B
Foreground/Acti
ve
starts
Background/
Paused
Back button will
pop top most
activity from
stack

33. R. Vasa, 201133
Activities are Stacked in
Android
•As additional activities are started, older
activities go into background
•All activities are placed on Activity Stack
Activity-AActivity-A
Activity-BActivity-B
Activity-CActivity-CForeground/Acti
ve
starts
starts
Background/Pause
d

34. R. Vasa, 201134
Short Problem 3 - Activity
Stacking
•Consider the following situation,
Activity-AActivity-A
Activity-BActivity-B
Activity-CActivity-C
starts
starts
Activity-AActivity-A
starts
Are these activities
the same object?
Ponder the interaction design
implications .....
Will Back Button Exit the
App?

35. R. Vasa, 201135
Lets get our feet wet

36. R. Vasa, 201136
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (using Global Variables)
•Passing Data Demo (using Intents)
•Controlling Input Type

37. R. Vasa, 201137
Demo 1 - Life Cycle of an Android
App.
•Walk-through of code provided along with
lecture handout.
•We can see the states by adding a little bit
of logging code to a few call-backs

38. R. Vasa, 201138
Life-Cycle Demo
onCreate, onStart,
onResume etc. are from the
Activity class

39. R. Vasa, 201139
Life-Cycle Demo (Watching
State)

40. R. Vasa, 201140
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (Global Variables)
•Application Manifest File
•Passing Data Demo (using Intents)
•Controlling Input Type

41. R. Vasa, 201141
Demo 2 - Passing Data

42. R. Vasa, 201142
Before data passing -- a quick
recap
•This app. makes use of nested layouts
•We can also make it look a bit nicer using
weights

43. R. Vasa, 201143
Anatomy of the App. (Nested
Layout)
Linear Layout
TextView
ImageView
Linear Layout
Button (Fruit)
Button (Vegetable)
Button (Drink)

44. R. Vasa, 201144
A Weighty Problem
Spot the difference in layout
How achieved? android:layout_weight=”1”
for all buttons in the layout

45. R. Vasa, 201145
Layout Weights are Handy
If all buttons are given the
same weight, then they will
be of same size

46. R. Vasa, 201146
Demo 2 - Passing Data
Activity - FoodMain Activity - FoodView
Data Passed:
Name (“Fruit”)
Image (fruit.png)

47. R. Vasa, 201147
Passing Data with Globals
•All Activities have a parent Application
object
•We can store data in this Application object
Activity-AActivity-A
Activity-CActivity-C
Activity-BActivity-B
ApplicatiApplicati
onon Activities have
a parent
application
We need to
extend the
Application class
to do this

48. R. Vasa, 201148
What Creates/Manages
Application?
•Application is created and managed by the
Android runtime
•There is one Application object created by
default
•We can extend the “Application Class” and
make our own
•But, we need to tell the Runtime about this
Application object via the Manifest XML
file

49. R. Vasa, 201149
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (Global Variables)
•Application Manifest File
•Passing Data Demo (using Intents)
•Controlling Input Type

50. R. Vasa, 201150
Manifest contains Application
Metadata
• Android runtime creates the Application object
• Application metadata is provided in the Manifest
XML
Manifest XML file is
part of the project
Auto-generated by Eclipse IDE

51. R. Vasa, 201151
Manifest XML - What is it?
Manifest informs Runtime about the App.Manifest informs Runtime about the App.

52. R. Vasa, 201152
Manifest XML - Contents
Application Name

53. R. Vasa, 201153
Manifest XML - Contains
Activity Names
Activity Name(s)

54. R. Vasa, 201154
Manifest XML - Refers to Icons
Launcher Icon

55. R. Vasa, 201155
Manifest XML - Refers to the
App. Name
Application
Label

56. R. Vasa, 201156
Passing Data with Globals
•All Activities have a parent Application
object
•We can store data in this Application object
FoodApplicatiFoodApplicati
onon
ApplicatiApplicati
onon
We need to
extend the
Application class
to do this
extends

57. R. Vasa, 201157
Global Vars. can be in the
Application
FoodApplicatiFoodApplicati
onon
ApplicatiApplicati
onon
extends

58. R. Vasa, 201158
Activities and Globals in
Application
•Activities can access data from the
Application object
We can also get to these variables from any Activi
(declared in the Manifest XML file)
We can also get to these variables from any Activit
(declared in the Manifest XML file)

59. R. Vasa, 201159
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (Global Variables)
•Passing Data Demo (using Intents)
•Controlling Input Type

60. R. Vasa, 201160
Demo 2 - Passing Data using
Intents
Activity - FoodMain Activity - FoodView
Data Passed:
Name (“Fruit”)
Image (fruit.png)

61. R. Vasa, 201161
Wiring up the Buttons (Another
Way)
Buttons
support onClick
in the layout
XML
Buttons
support onClick
in the layout
XML

62. R. Vasa, 201162
Storing Data in a Bundle

63. R. Vasa, 201163
Sending an Async. Message
Android uses an asynchronous messaging
model (known as Intents) to send messages
between Activities
Android uses an asynchronous messaging
model (known as Intents) to send messages
between Activities

64. R. Vasa, 201164
Sending an Async. Message
Setup Message and Store
Data in the Message
Setup Message and Store
Data in the Message

65. R. Vasa, 201165
Sending an Async. Message
Class that is sending
the Intent (message)
Class that is sending
the Intent (message)

66. R. Vasa, 201166
Sending an Async. Message
Class that will receive
the Intent (message)
Class that will receive
the Intent (message)
Class that is sending
the Intent (message)
Class that is sending
the Intent (message)

67. R. Vasa, 201167
Sending an Async. Message
Send the Message to the Activity
(Transmit)
Send the Message to the Activity
(Transmit)

68. R. Vasa, 201168
Message Receiving
Retrieve data from the
message
Retrieve data from the
message

69. R. Vasa, 201169
Intent Messages are
Asynchronous
•The intent system is completely
asynchronous -- similar to e-mail
•That is,
•The receiver will get the message only if
they request to see intents via getIntent()
method
•All transmitted messages are placed on a
‘Service Queue’

70. R. Vasa, 201170
Complex Domain Models
•Where do you hold a complex domain
model?(E.g. we have 4-5 classes in a
domain model)
•We can hold a reference to the domain
model objects in the Application
•This is fine if there are only a few objects
•Unlike Activity, Application is only terminated
if device runs low on memory
•If the data size is larger -- then best to use
the sqlite database

71. R. Vasa, 201171
Lecture Overview
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (Global Variables)
•Passing Data Demo (using Intents)
•Controlling Input Type

72. R. Vasa, 201172
Controlling Input Data Type
•A common task on forms is to restrict users
to certain data types
•Email Address
•Decimal Numbers
•Positive Integers
•Alpha Numeric
•On mobile devices -- development
platforms offer a simple way to control the
keyboard type

73. R. Vasa, 201173
Controlling Input Type
(Android)
•Android has a large number of options
•You can merge them to create more
complex input types
textUri
textEmailAddress
textPassword
textPersonName
number
numberSigned
numberDecimal
numberPassword
textUri
textEmailAddress
textPassword
textPersonName
number
numberSigned
numberDecimal
numberPassword
android:inputTypeandroid:inputType

74. R. Vasa, 201174
Input Type - Example
http://developer.android.com/reference/android/widget/TextView.html#attr_andro
id:inputType
More info. at the following URL

75. R. Vasa, 201175
Lecture Recap
•Recap (previous 2 weeks)
•Passing Data between Activities
•Data passing methods
•Activity Design Choice
•Activity Life Cycle
•Passing Data Demo (Global Variables)
•Passing Data Demo (using Intents)
•Controlling Input Type

76. R. Vasa, 201176
What’s next?
•Usability Principles - Mobile Form Design
•Using Dialogs
•Returning data back from an Activity
•Simple File I/O
•More complex layouts
•Exploring a few more widgets