Download Programming Android applications: an incomplete introduction

Programming Android applications:
an incomplete introduction
J. Serrat
Software Design
December 2013
Preliminaries : Goals
●
Introduce basic programming Android concepts
●
Examine code for some simple examples
●
Limited to those relevant for the project at hand
●
Provide references to best materials for self
study, read them before programming , trial and
error takes longer
●
Understand provided project implementation
●
Homework for a quick start
Preliminaries: why Android
●
●
Many students own an Android phone
Known and free development environment
(Android SDK + Eclipse + ADK plugin)
●
Well documented
●
Good chance to learn UI design
●
●
Take away course project in your pocket, funny to
see and show your software running in a phone
Starting point to learn more on mobile
development
Preliminaries: why Android
●
●
●
Drawbacks: learning curve, lots of details
Many things left out: fragments, programming
action bars, themes...
How to learn: try to solve small problems in
separate projects, like
●
create an action bar wit actions and overflow
action
●
customize a ListView to show name and time
●
make a contextual action bar
Contents
1. References
2. Development framework
3. Building blocks
4. Structure of an Android project
5. Activity life cycle
6. Views, Layouts
Contents
7. Menus
8. Action bar
9. Intents, Broadcast receivers, Adapters
10. Dialogs, Preferences
11. Services
12. TimeTracker architecture
References
Published since 2010 (O'Reilly, Apress, Wrox, Manning)
and
many
more ...
References
Professional Android 4 application
development. Reto Meier. Wiley, 2012.
Complete, comprehensive, basic and advanced
topics. I used the Android 2 version to learn.
Source code at eu.wiley.com
Hello, Android. 3rd Edition. Ed Burnette.
The pragmatic programmers, 2010.
Simpler, only basic topics. Sudoku application.
Source code at
http://pragprog.com/book/eband3/hello-android
Android UI fundamentals: develop and
design. Jason Ostrander. Peachpit, 2012.
Focused on UI only. Example application: a time
tracker (1 level). Source code at
www.peachpit.com/androiduifundamentals
References
December 2013
http://cataleg.uab.cat/search*cat/X?SEARCH=%28android%29&SORT=D
References
http://developer.android.com/training/index.html
References
In Eclipse, you can
install many (legacy)
application
examples :
File → New → Other
→ Android → Sample
project
...
References
Load examples as Eclipse
projects: File → New
Android project →
create from existing
sample → Api demos
Run and see source code
for the API demos.
Virtual device emulator
References
For example, in emulator:
Api Demos → Views →
Controls → Light theme
and in Eclipse:
res/layout/controls_1.xml
apis.views/controls1.java
Development framework
http://developer.android.com/resources/dashboard/platform-versions.html
Development framework
1.6
2.2
4.0
Building blocks
Main logical components of Android applications :
●
Activity : UI component typically corresponding to
one screen. They contain views = UI controls like
buttons, editable text boxes...
May react to user input and events (intents)
An application typically consists of several
screens, each screen is implemented by one
activity.
Moving to the next screen means starting a new
activity. An activity may return a result to the
previous activity.
Building blocks
●
●
Service : application part that runs in background
without the user’s direct interaction, similar to a
Unix daemon. For example, a music player.
Content provider : generic interface to manage
(access, change) and share (like “contacts”)
application data. Can be stored as SQLite
databases.
Application
Activity
Activity
Application
Application
Activity
Content Resolver
Service
Content Resolver
Content Provider
Content Resolver
Data
file
SQLite
XML
file
Remote
Store
Building blocks
●
Intent : “messages” sent by an activity or service
in order to


launch an activity = show a new screen
broadcast (announce) that a certain event has
occurred so that it can be handled
Fundamental to decouple cooperating application
components.
●
Post 3.0 APIs include some more components:
fragments, tasks...
Building blocks
Structure of an Android project:
create and run a “Hello world” application, File →
New → Android application project → ...
Do not close the
emulator! It takes a
lot to start.
Each time you build
the project, the new
version is uploaded
and execution starts
automatically.
HelloWordActivity.java
Automatically
generated code
HelloWordActivity.java
Autogenerated class R
“Inflates” the UI from the
main.xml file specifying it
values/strings.xml
Place to define UI constant
strings, values, arrays of integers
and strings, colors, size of things
(dimensions)...
Can use the Resources assistant
to edit.
values/strings.xml
Message displayed
in the screen
AndroidManifest.xml
other views
xml view
AndroidManifest.xml
●
●
includes xml nodes for each of the application
components : Activities, Services, Content
Providers and Broadcast Receivers
using intent filters to specify how they interact
with each other:


●
which activities can launch another activity or
service
which broadcast intents an activity listens to,
in order to handle them with a receiver ...
offers attributes to specify application metadata
(like its icon or theme)
AndroidManifest.xml
Won't start on
devices supporting
an older API
This activity may be the
application entry point.
layout/main.xml
The interface design is represented in XML,
decoupling design from code (opposite to
“programmatic UI”). A call “inflates” the UI.
Layout is a special view that contains other
views in specific spatial arrangements.
LinearLayout arranges its children in a single
column or row.
TextView is a non-editable text label.
XML view of the UI design
layout/main.xml
string id defined
in string.xml
layout/main.xml
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textViewTitol"
android:text="TubeQuoter V0.10" />
<TableLayout
android:id="@+id/tableLayout1"
android:layout_marginLeft="20dp" >
<TableRow
android:id="@+id/tableRow1">
<TextView
android:id="@+id/textViewLabelLongitud"
android:text="Longitud" />
<EditText
android:id="@+id/editTextLongitud"
android:inputType="number" >
<requestFocus />
</EditText>
<TextView
android:id="@+id/textViewLabelUnitatsLongitud"
android:text="mm" />
</TableRow>
:
:
</TableLayout>
<Button
android:id="@+id/butocalcul"
android:text="Calcula" />
</LinearLayout>
layout/main.xml
Graphical view of
the UI design,
better to design.
Select item and
edit properties.
Activity Life Cycle
●
●
●
Many Android devices have limited memory,
CPU power, and other resources.
The OS assures the most important processes
get the resources they need.
In addition, the OS takes
responsiveness very seriously:
if the application does not
answer user input (key
press...) in < 5 secons, the
ANR dialog appears.
Activity Life Cycle
●
●
●
Each application runs in its own
process, which has a main
thread, within which activities,
services... run
The OS ranks processes and
kills those with lowest
priority, if some application
needs unavailable resources.
If a process is killed “in the middle”, somehow
data can not be lost.
Activity Life Cycle
Android in practice. Collins, Galpin, Käpler. Manning, 2012.
Activity Life Cycle
States of an activity
and methods invoked
when changing state
Activity is active =
visible in foreground
interacting with user
Not visible. Will remain in memory. Need to save data, such as a database record being edited. Hello Android. Ed Burnette. The Pragmatic Programmer, 2010
Activity is visible
in background
States of an activity
and methods invoked
when changing state.
Changing orientation
landscape ←→ portrait
calls onDestroy() +
onCreate(). Ctrl-F11
on virtual device.
Homework Recap
●
●
●
Get some recommended book AND read
developer.android.com/training main topics
Load API demos in Eclipse : File → New → Other
Android → Android project from existing code +
select <SDK folder>/android-18/samples/legacy
Create a Hello world project
●
with string and icon resources
●
try different nested layouts
Views, Layouts
Control: extension of class View that implements
some simple functionality, like a button.
ViewGroup : extensions of the View class that can
contain multiple child Views (compound controls).
Layout managers, such as LinearLayout.
Activities represent the screen being displayed to
the user. You assign a View or layout to an Activity:
HelloWordActivity.java
main.xml
Views, Layouts
Controls: catalog and appearance depends on API
level.
Look at
●
Eclipse Graphical layout editor : shows controls
depending on the API level of your project.
●
Run Api Demos → Views
●
developer.android.com/guide/components
Views, Layouts
Common controls : TextView, EditText (many
types), Button, ListView, ExpandableList, Spinner,
Checkbox, ProgressBar, SeekBar, RadioGroup,
RatingBar, Time and Date Picker …
Views, Layouts
Layouts control the position of child controls on a
screen.
Common layouts:
●
●
●
LinearLayout adds each child View in a straight
line, either vertically or horizontally
RelativeLayout define the positions of child
Views relative to each other or screen boundaries
TableLayout lay out Views using a grid of rows
and columns
Can be nested, creating arbitrarily complex
interfaces.
Views, Layouts
LinearLayout
1
1
2
3
1
2
2
3
4
4
Views, Layouts
RelativeLayout
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textViewTitol"
android:text="TubeQuoter V0.10" />
<TableLayout
android:id="@+id/tableLayout1"
android:layout_marginLeft="20dp" >
<TableRow
android:id="@+id/tableRow1">
<TextView
android:id="@+id/textViewLabelLongitud"
android:text="Longitud" />
<EditText
android:id="@+id/editTextLongitud"
android:inputType="number" >
<requestFocus />
</EditText>
<TextView
android:id="@+id/textViewLabelUnitatsLongitud"
android:text="mm" />
</TableRow>
:
:
</TableLayout>
<Button
android:id="@+id/butocalcul"
android:text="Calcula" />
</LinearLayout>
Views, Layouts
ToDoList example : how to react to user input ?
How to bind data to the UI (lists) ?
Write to the edit box and
then press D-Pad or
Enter to add as a new
item to the ToDo list.
D-Pad
Views, Layouts
Views, Layouts
From now on, changes on ArrayList todoItems are
shown in the screen when adapter notifies it.
Views, Layouts
Java anonymous
class
Override onKey of
class onKeyListener
Which listeners
has an EditText ?
Views, Layouts
It is possible to customize the aspect and content of
items in a ListView. See Ch. 4 Reto Meier's book and
source code at www.wrox.com
Contents
7. Menus
8. Action bar
9. Intents, Broadcast receivers, Adapters
10. Dialogs, Preferences
11. Services
12. TimeTracker architecture
Menus
Present application functionality using little screen
space.
Each Activity can specify its own menu.
Difference between pre and post 3.0 platform (API
level 10):
●
●
pre: physical menu button on the device, three
levels of menus: options, expanded, submenu
post: superseded by the action bar
Menus
phones with physical
navigation keys
virtual navigation
controls
Menus
Three types of menus
1. Options menu
●
at the bottom of screen
●
icons and text
●
●
if more than 6 items, a More item is displayed
that opens an Expanded menu
On Android 3.0 and higher, items from the
options menu are presented by the action bar
Menus
expanded
menu
action bar
Menus
2. Context menu
●
●
●
floating menu that appears when the user
performs a long-click on an element
similar to “right-click” menu
provides actions that affect the selected
content, normally an item of a ListView
Menus
2. Context menu
●
from Android 3.0 on, better use a contextual
action bar to present actions the user can
perform on the currently selected item
contextual
action bar:
actions
depend on
selected
item(s)
context
menu
pre 3.0
3.0+
Menus
3. Popup or submenu
●
●
●
modal menu anchored to a View, appears
below or above it
good to provide an overflow of actions that
relate to specific content or to provide options
for a second part of a command/menu item
no icons
submenu
title
action overflow :
less often used
actions
Menus
3. Popup or submenu
●
●
but can't be nested: a submenu item can not
expand another submenu
On Android 3.0+ : actions should not directly
affect the corresponding content—that's what
contextual actions are for
Context menu
and submenu
for an item
Menus
Programming (1)
Recommended: define menu items and properties
as a menu resource in XML , not in the code
●
●
●
●
easier to visualize the menu structure
allows to create alternative configurations for
different platform versions, screen sizes...
compact code: menu is inflated by a single
call
can use Eclipse's resource editor
Menus
Menus
string resource name that will appear in
the UI, better use array of strings in xml
to reference the menu options in
the code : what's been selected?
Menus
Programming (2)
Override Activity method to inflate the xml menu
res/menu/game_menu.xml
Menus
Programming (3)
Program event handling : when the user selects
an item from the options menu (also action items
in the action bar), the system calls the activity's
method
selected item
item ids
Menus
Spinners offer similar functionality:
multiple choice selection from
exclusive options on a dropdown
menu.
Not a menu
control!
Menu items can
contain radiobuttons
but also checkboxes
and form groups
Action bar
Replaces the options menu in
Android 3.0+ with buttons ('action
items')
One of the most important design
elements of an Android app. :
●
●
●
dedicated piece of screen
visible throughout the app.
running
makes our app. consistent with
the core Android apps.
Action bar
Examples
Action bar
Purposes :
●
●
●
●
make important actions prominent and
accessible [3]
support consistent navigation and view
switching [2] (with spinner or tabs)
reduce clutter by providing an action overflow
for rarely used actions [4]
show app identity [1]
app.
icon
spinner
action
buttons
action
overflow
Action bar
Action bars can be split
If the user can navigate,
contains the up caret, at
a minimum
To quickly switch between
the views, use tabs or a
spinner in the top/main
action bar
Display actions and, if
necessary, the action
overflow
main
action
bar
top
bar
bottom
bar
Action bar
spinner
action
overflow
Dialogs
Small windows displayed over the
screen.
modal: block all user input and
must be dismissed before the user
can continue.
●
partially obscures the Activity that
launched it.
●
Purposes :
answer questions Yes/No, Ok/Cancel...
make selections
read warning or error messages
show bar progress
Dialogs
Dialog share a common structure:
●
●
●
Optional title region: Introduces
content
Content area: text, UI elements,
text fields, checkboxes, etc...
Action Buttons: Typically
OK/Cancel, indicating the
preferred option.
Dialogs
Special types of Dialogs:
●
●
●
Alerts: Inform user from a
situation that requires
confirmation.
Pop-ups: Lightweight
dialogs with a single
selection from the user.
Toasts: Small pop-up that
feedbacks about
something. Disappear
automatically.
Dialogs
Programming (1)
Dialogs should normally be created(instantiated)
within the Activity's onCreateDialog(int). This is
called only the first time the dialog is showed.
To show the dialog, call showDialog(int)
To change dialog properties each time the dialog
is opened, define onPrepareDialog(int)
1st call showDialog(id)
2nd call showDialog(id)
onCreateDialog(id)
onPrepareDialog(id)
onPrepareDialog(id)
Dialogs
Programming (2)
The best way to define onCreateDialog(int) is with
a switch statement that checks the id of the
dialog being created. The method must return the
dialog created.
Dialogs
Programming (3)
When it's time to show one of the dialogs, call
showDialog with the desired ID.
To close a dialog, you can dismiss it by calling
dismiss() from the Dialog object. If necessary, you
can also call dismissDialog(int) from the Activity.
Preferences
Android provides classes to
manage application preferences
and implement the preferences UI.
●
●
ensures consistency, with
specific UI elements (e.g
ListPreference)
all preferences within each
application is maintained in the
same manner.
Preferences
The SharedPreferences class:
●
●
●
provides a general framework to save and
retrieve key-value pairs.
there is a single instance of this class.
its data will persist across user sessions (even if
the app is killed)
Preferences
Steps to implement the Preferences:
1. Add string resources needed for preferences.
Preferences
2. Create the preferences UI layout (using
standard Preference UI elements).
We can reference
the string
resources
Preferences
3. Create the Preferences Activity, and inflate the
layout overriding the onCreate method.
4. Add static string values to identify each of the
preferences by a unique key.
Preferences
5. Implement the OK/Cancel listeners and a
method to save preferences.
This method commits changes
on the sharedPreferences object
Preferences
5. Implement the OK/Cancel listeners and a
method to save preferences.
Add pairs
“string,value” to the
SharedPreferences
object
Commit changes. If
the preferences file
MYPREFS does not
exist, it will be created
Preferences
6. Apply the preferences when the activity starts.
Preferences file
name. If it does not
exist will be created
when committing
changes
Default value if it is
not defined
Unique preference
key (string)
Intents
Intents is a fundamental concept in Android
development : “the glue that binds applications'
components”.
Message-passing mechanism to
●
●
explicitly or implicitly start an Activity or a
Service
broadcast that an event has occurred,
application or system-wide
to handle user action or process a piece of data
Intents
Intents
origin
context
activity
to start
Intents can return a result: startActivityForResult()
Intents
Need to declare all activities in AndroidManifest.xml
Broadcast Receivers
Intents can also be used to broadcast messages
to anonymous components with one same
application.
The sender can associate data to those intents.
A broadcast receiver (maybe within other app.
component):
●
listens for selected types of broadcast intents
●
responds to them = processes associated data
'Anonymous' implies components are loosely
coupled, do not need to know each other.
Broadcast Receivers
NEW_LIFE
String name
double longitude
double latitude
On button click a broadcast intent of type
“NEW_LIFE” is sent, along with three data fields.
A broadcast receiver object has subscribed to this
type of messages in the AndroidManifest.xml.
The receiver does not belong to an Activity or
Service in this case.
Response is printing a message.
Broadcast Receivers
Broadcast Receivers
Broadcast
intent type
data
field
names
Broadcast Receivers
The broadcast receiver will always be
active (listening), even when MyActivity
has been killed or not started
Broadcast Receivers
Register the receiver when MyActivity is visible and
unregister when not.
Typically when the receiver updates am UI element.
TimeTracker architecture
LlistaActivitatsActivity.java
LlistaIntervalsActivity.java
ListView
controls
TimeTracker architecture
Harder to destroy
by Android OS than
activities
Contains the actual
activities and intervals
tree
Analogous to TimerTask or Timer,
which are not usable in Android.
See code comments and
references there.
TimeTracker architecture
Show a part of the
tree, the childs of
some node
. root
P P T P T
P P T
I I I
different fields
TimeTracker architecture
DONAM_FILLS
PUJA_NIVELL
BAIXA_NIVELL
DONAM_FILLS
ENGEGA_CRONOMETRE
PARA_CRONOMETRE
PUJA_NIVELL
TimeTracker architecture
TE_FILLS + array of
project and task
data : dates and
duration
TE_FILLS + array of
interval data :
name, dates and
duration
TimeTracker architecture
Intent data to activities is a
serialized array list of these
objects.
This avoids serializing the
whole or a subtree of activities
and intervals, slow if the tree is
large!
(need to do it every 2 secs.)
Creates a random synthetic
but data-consistent large tree
(durations and dates)