Android Introduction

Android Programming
Daniela da Cruz
Instituto Politécnico do Cávado e do Ave
III Jornadas de Tecnologia
May 6, 2013
1 of 14

The Story
Advantages of using Android
Disadvantages of using Android
What will be done along this workshop?
How to start programming?
2 of 14

The Story
- Android is a is a Linux-based operating system for smartphones and
tablets created by Google.
- Developers write applications in a customized version of Java, and
apps can be downloaded from online stores such as Google Play
(formerly Android Market), the app store run by Google, or third-party
sites.
- In June 2012, there were more than 600 000 apps available for
Android, and the estimated number of applications downloaded from
Google Play was 20 billion (according to
http://www.engadget.com).
3 of 14

Advantages of using Android
• The Android OS is simple to learn, and Google provides many
libraries to make it easy to implement rich and complex applications
• Multitasking: Android phones can run many applications, it means
you can browse Facebook while listening a song.
• Easy access to thousands of applications via the Google Android
App Market.
• Phone options are diverse: dierent from iOS that is limited to
iPhone from Apple, Android is available on mobile phones from
various manufacturers (Sony Ericsson, Motorola, HTC to
Samsung).
10 of 14

Disadvantages of using Android
• The only aspect lacking, as mentioned by many in the Android
developer community, is clear and well-explained documentation.
• Advertising: application in the Android phones can indeed be
obtained easily and for free, but the consequences in each of these
applications, will always be ads on display, either the top or bottom
of the application.
11 of 14

What will be done in this workshop?
• The classical Hello World!
• Take a pic and show it in our app
• Show a Google Map and change its center using our location
12 of 14

How to start programming?
• Download and install the Android SDK (4.2 version - Jelly Bean)
it provides the API libraries and developer tools necessary to
build, test, and debug apps for Android.
Details on http://developer.android.com/sdk/index.html
Pre-requisites:
• Eclipse 3.6.2 (Helios) or greater
• Eclipse JDT plugin (included in most Eclipse IDE packages)
• JDK 6 (JRE alone is not sucient)
• Android Development Tools plugin (recommended)
13 of 14

Android Application Overview
Activity Lifecycle
Basic Android User Interface components
Activity
Fragments
View and ViewGroup
Layouts
AbsoluteLayout
FrameLayout
LinearLayout
RelativeLayout
TableLayout
XML Layout Attributes
Dimensions
2 of 20

Android Application Overview
An Android application consists of various functionalities. Some
examples are editing a note, playing a music file, ringing an alarm, or
opening a phone contact.These functionalities can be classified into
four different Android components:
Every application is made up of one or more of these components.
3 of 20

Activity Lifecycle
Note the following:
• Changing the screen orientation destroys and recreates the activity
from scratch.
• Pressing the Home button pauses the activity, but does not destroy
it.
• Pressing the Application icon might start a new instance of the
activity, even if the old one was not destroyed.
• Letting the screen sleep pauses the activity and the screen
awakening resumes it. (This is similar to taking an incoming phone
call.)
5 of 20

Activity
An Activity represents the visual representation of an Android
application.
Activities use Views and Fragments to create the user interface and
to interact with the user.
An Android application can have several Activities.
6 of 20

Fragments
Fragments are components which run in the context of an Activity.
Fragment components encapsulate application code so that it is easier
to reuse it and to support diﬀerent sized devices.
Fragments are optional, you can use Views and ViewGroups directly in
an Activity but in professional applications you always use them to
allow the reuse of your user interface components on diﬀerent sized
devices.
7 of 20

View and ViewGroup
Views are user interface widgets, e.g. buttons or text ﬁelds. The base
class for all Views is the android.view.View class. Views have attributes
which can be used to conﬁgure their appearance and behavior.
A ViewGroup is responsible for arranging other Views. ViewGroups is
also called layout managers. The base class for these layout managers
is the android.view.ViewGroup class which extends the View class.
ViewGroups can be nestled to create complex layouts. You should not
nestle ViewGroups too deeply as this has a negative impact on the
performance.
8 of 20

View and ViewGroup
The user interface for each component of your app is defined using a
hierarchy of View and ViewGroup objects.
The easiest and most effective way to define a layout is with an XML
file.
9 of 20

Layouts
An Android layout is a class that handles arranging the way its
children appear on the screen. Anything that is a View (or inherits
from View) can be a child of a layout. All of the layouts inherit from
ViewGroup (which inherits from View) so you can nest layouts.
The standard Layouts are:
• AbsoluteLayout
• FrameLayout
• LinearLayout
• RelativeLayout
• TableLayout
10 of 20

At compile time, references to the resources are gathered into an
auto-generated wrapper class called R.java. The Android Asset
Packaging Tool (aapt) autogenerates this ﬁle.
The syntax for an ID, inside an XML tag is:
android:id=@+id/my_button
The at-symbol (@) at the beginning of the string indicates that the
XML parser should parse and expand the rest of the ID string and
identify it as an ID resource. The plus-symbol (+) means that this is a
new resource name that must be created and added to the R.java ﬁle.
16 of 20

When referencing an Android resource ID, you do not need the
plus-symbol, but must add the android package namespace, like so:
android:id=@android:id/empty
With the android package namespace in place, we’re now referencing
an ID from the android.R resources class, rather than the local
resources class.
17 of 20

In order to create views and reference them from the application, a
common pattern is to:
1. Deﬁne a view/widget in the layout ﬁle and assign it a
unique ID:
Button android:id=@+id/my_button
android:layout_width=wrap_content
android:layout_height=wrap_content
android:text=@string/my_button_text/
18 of 20

In order to create views and reference them from the application, a
common pattern is to:
2. Then create an instance of the view object and capture
it from the layout (typically in the onCreate() method):
Button myButton = (Button) findViewById(R.id.my_bu
Deﬁning IDs for view objects is important when creating a
RelativeLayout. In a relative layout, sibling views can deﬁne their
layout relative to another sibling view, which is referenced by the
unique ID.
19 of 20

Dimensions
A dimension is speciﬁed with a number followed by a unit of measure.
The following units of measure are supported by Android:
• dp — Density-independent Pixels: An abstract unit that is based on
the physical density of the screen. These units are relative to a 160
dpi (dots per inch) screen, on which 1dp is roughly equal to 1px.
When running on a higher density screen, the number of pixels used
to draw 1dp is scaled up by a factor appropriate for the screen’s dpi.
• sp — Scale-independent Pixels: This is like the dp unit, but it is
also scaled by the user’s font size preference.
• pt — Points: 1/72 of an inch based on the physical size of the
screen.
20 of 20

Dimensions
A dimension is speciﬁed with a number followed by a unit of measure.
The following units of measure are supported by Android:
• px — Pixels: Corresponds to actual pixels on the screen. This unit
of measure is not recommended because the actual representation
can vary across devices.
• mm — Millimeters: Based on the physical size of the screen.
• in — Inches: Based on the physical size of the screen.
21 of 20

Intents
Explicit Intents
Implicit Intents
Using Intents to call Activities
Calling Sub-Activities for result data
2 of 8

Intents
Intents are asynchronous messages which allow Android components
to request functionality from other components of the Android system.
For example an Activity can send an Intents to the Android system
which starts another Activity.
An Intent can also contain data. This data can be used by the
receiving component.
There are two types of Intents: Explit and Implict.
3 of 8

Explicit Intents
Explicit Intents explicitly deﬁnes the component which should be
called by the Android system, by using the Java class as identiﬁer.
The following shows an explicit Intent.
Explicit Intents are typically used within on application as the classes
in an application are controlled by the application developer.
4 of 8

Implicit Intents
Implicit Intents do not directly specify the Android components which
should be called.
For example the following tells the Android system to view a webpage.
If these Intents are send to the Android system it searches for all
components which are registered for the speciﬁc action and the data
type.
If only one component is found, Android starts this component
directly. If several components are identiﬁer by the Android system,
the user will get an selection dialog and can decide which component
should be used for the Intent.
5 of 8

Retrieving data from Intents
The component which receives the Intent can use the
getIntent().getExtras() method call to get the extra data.
6 of 8

Using Intents to call Activities
If you send an Intent to the Android system, Android requires that you
tell it to which type of component your Intent should be send.
To start an Activity use the method startActivity(Intent). This
method is deﬁned on the Context object and available in every
Activity object.
If you call an Activity with the startActivity(Intent) method the
caller requires no result from the called Activity.
7 of 8

Calling Sub-Activities for result data
If you need some information from the called Activity use the
startActivityForResult() method.
If you use the startActivityForResult() method then the started
Activity is called a Sub-Activity.
8 of 8

Bibliography
• Android - Introdução ao Desenvolvimento de Aplicações, Ricardo
Queirós (Abril 2013).
• Programming Android. Zigurd Mednieks, Laird Dornin, G. Blake
Meike, Masumi Nakamura. O'Reilly Media. July 2011
• The Android Developer's Cookbook: Building Applications with the
Android SDK. James Steele, Nelson To.
• http://www.learn-android.com
• http://www.vogela.com
14 of 14

Android Introduction

More Related Content

What's hot (19)

Viewers also liked (13)

Similar to Android Introduction (20)

More from Daniela Da Cruz (7)

Recently uploaded (20)

Android Introduction