Parts Of Hello World App

Parts of a Android application

1.1.Android application

An Androidapplicationis a single installable unit which can be started and used

independently of other Android applications.

An Android application can have one application class which is instantiated as soon as the
application starts and it is the last component which is stopped during application
shutdown.

An Android application consists of Android software components and resource files.

Android application components can connect to components of other Android applications
based on a task description (Intent). This way they can create cross-application tasks. The
integration of these components can be done in a way that the Android application can still
work flawless, even if the additional components are not installed or if different components
perform the same task.
1.2.Android software components

The following software components can be defined in Android applications.

I. Activities
II. Intents
III. Services
IV. Broadcast receivers (short: receivers)
V. Content providers (short: providers)

1.3. Context

Instances of the class android.content.Context provide the connection to the Android system which
executes the application. It also gives access to the resources of the project and the global information
about the application environment.

For example, you can check the size of the current device display via the Context.

The Context class also provides access to Android services, e.g., the alarm manager to trigger time
based events.

Activities and services extend the Context class. Therefore they can be directly used to access the
Context.
2.Android application components overview

2.1.Activity
Anactivityis the visual representation of an Android application. An Android application can have several
activities. Activities useviewsandfragmentsto create the user interface and to interact with the user. Both
elements are described in the next sections.

2.2.BroadcastReceiver
Abroadcast receiver(receiver) can be registered to listen to system messages and intents. A receiver gets
notified by the Android system if the specified event occurs. For example, you can register a receiver for the
event that the Android system finished the boot process. Or you can register for the event that the state of the
phone changes, e.g., someone is calling.

2.3.Service
Aserviceperforms tasks without providing an user interface. They can communicate with other Android
components, for example, via broadcast receivers and notify the user via the notification framework in Android.
2.4.ContentProvider

Acontent provider(provider) defines a structured interface to application data. A

provider can be used for accessing data within one application, but can also be used to
share data with other applications.

Android contains an SQLite database which is frequently used in conjunction with a

content provider. The SQLite database would store the data, which would be accessed via
the provider.

2.5.Intent

An Android Intent is an abstract description of an operation to be performed. It can be

used with startActivity to launch an Activity, broadcastIntent to send it to any interested
BroadcastReceiver components, and startService(Intent) or bindService(Intent,
ServiceConnection, int) to communicate with a background Service.

The intent itself, an Intent object, is a passive data structure holding an abstract
description of an operation to be performed.
3.Base user interface components in Android

The following description gives an overview of the most important user interface related component and parts
of an Android application.

3.1.Activity
Activities are the base for the user interface in Android.

3.2.Fragments

Fragments are components which run in the context of an activity. A fragment encapsulates application code
so that it is easier to reuse them and to support devices of different size.

The following picture shows an activity calledMainActivity. On a smaller screen it shows only one fragment
and allows the user to navigate to another fragment. On a wide screen it shows those two fragments
immediately.
3.3. Views and layout manager

Views are user interface widgets, e.g., buttons or text fields. Views have
attributes which can be used to configure their appearance and behavior.

A ViewGroup is responsible for arranging other views. It is also known as

layout manager. The base class for these layout managers is the
android.view.ViewGroup class which extends the android.view.View class which
is the base class for views.

Layout managers can be nested to create complex layouts.

3.4. Device configuration specific layouts

The user interface for activities is typically defined via XML files (layout files).
It is possible to define layout files for different device configuration, e.g.,
based on the available width of the actual device running the application.
4.Other important Android elements

4.1.Home screen and lock screen widgets

Widgetsare interactive components which are primarily used on the Android

home screen. They typically display some kind of data and allow the user to
perform actions with them. For example, a widget can display a short summary
of new emails and if the user selects an email, it could start the email application
with the selected email.

To avoid confusion with views (which are also called widgets), this text uses
the termhome screen widgets, if it speaks about widgets.

4.2.Live Wallpapers
Live wallpapersallow you to create animated backgrounds for the Android
home screen.
5. The Android manifest

5.1. Configuration of your Android application

The components and settings of an Android application are described in the

AndroidManifest.xml file. This file is known as the manifest file or the manifest.

The manifest also specifies additional metadata for the application, e.g., icons and the
version number of the application.

This file is read by the Android system during installation of the application. The Android
system evaluates this configuration file and determines the capabilities of the application.

5.2. Declaring components in the manifest file

All activities, services and content provider components of the application must be statically
declared in this file. Broadcast receiver can be defined statically in the manifest file or
dynamically at runtime in the application.

5.3. Permissions

The Android manifest file must also contain the required permissions for the application. For
example, if the application requires network access, it must be specified here.
13.4.Android manifest example
The following listing shows an example for a simple Android manifest file.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.rssreader"
android:versionCode="1"
android:versionName="1.0" >

<uses-sdk
android:minSdkVersion="16"
android:targetSdkVersion="19" />

<uses-permission android:name="android.permission.INTERNET" />

<application
android:name="RssApplication"
android:allowBackup="false"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="RssfeedActivity"
android:label="@string/title_activity_main" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
<activity
android:name=".DetailActivity"
android:label="Details" >
</activity>
<activity android:name="MyPreferenceActivity" >
</activity>

<service android:name="RssDownloadService" >

</service>
</application>

</manifest>
6. More details of the Android manifest

6.1. Version and package

The package attribute defines the base package for the Java objects referred to in this file. If a Java
object lies within a different package, it must be declared with the full qualified package name.

Google Play requires that every Android application uses its own unique package name. Therefore it is
a good habit to use your reverse domain name here. This will avoid collisions with other Android
applications.

android:versionName and android:versionCode specify the version of your application. versionName is

what the user sees and can be any string.

versionCode must be an integer. The Android Market determines whether it should perform an update
of the applications for the existing installation based on that versionCode. You typically start with "1"
and increase this value by one if you roll-out a new version of your application.
 6.2. Application and components

The <application> section allows to define metadata for your application and optionally define
an explicit application class. It is also a container for declaring your Android components.

The <activity> tag defines an activity component. The name attribute points to class, which (if
not fully qualified) is relative to the package defined in the package attribute.

The intent filter part in the Android manifest file, tells the Android runtime that this activity
should be registered as a possible entry point into the application and made available in the
launcher of the Android system. The action defines that it
(android:name="android.intent.action.MAIN" ) can be started and the category
android:name="android.intent.category.LAUNCHER" parameter tells the Android system to add
the activity to the launcher.

The @string/app_name value refers to resource files which contain the actual value of the
application name. The usage of a resource file makes it easy to provide different resources
(e.g., strings, colors, icons) for different devices and makes it easy to translate applications.

Similar to the <activity> tag, you can use the service, receiver and provider to declare other
Android components.
6.3. Minimum and target SDK

The uses-sdk section in the manifest allows you to specify the minSdkVersion and
targetSdkVersion version of your application.

Table : Minimum and target version

Value Description
minSdkVersion Define the minimum version of Android your
application works on. This attribute is used as a filter
in Google Play, i.e., a user cannot install your
application on a device with a lower API level than
specified in this attribute.

targetSdkVersion Specifies the version on which you tested and

developed. If it is not equal to the API version of the
Android device, the Android system might apply
forward- or backward-compatibility changes. It is
good practice to always set this to the latest Android
API version to take advantages of changes in the
latest Android improvements.
 6.4. Permissions

Your application can declare permissions with the <permission> tag and declare that it required a
permision with the <uses-permission> tag.

6.5. Required device configuration

The uses-configuration section in the manifest allows you to specify required input methods for your
device. For example, the following snippet would require that the device has a hardware keyboard.

<uses-configuration android:reqHardKeyboard="true"/>

The uses-feature section allows you to specify the required hardware configuration for your device. For
example, the following snippet would require that the device has a camera.
<uses-feature android:name="android.hardware.camera" />

6.6. Installation location

Via the installLocation attribute of your application you can specify if your application can be installed on the
external storage of the device. Use auto or preferExternal to permit this.

Warning In reality this option is rarely used, as an application installed on the external storage is stopped
once the device is connected to a computer and mounted as USB storage.
7. Resources

7.1. Resource files

Android allows you to create static resources like images and XML configuration
files. This allows you to keep these resources separate from the source code of
your Android application.

Resource files must be placed in the /res directory of your application in a

predefined sub-folder. The specific sub-folder depends on type of resource which
is stored.

The following table gives an overview of the supported resources and their
standard folder prefixes.
Table :Resources

Resource Folder Description

Drawables /res/drawables Images (e.g., png or jpeg files) or
XML files which describe a
Drawable object.
Simple Values /res/values Used to define strings, colors,
dimensions, styles and static
arrays of strings or integers via
XML files. By convention each type
is stored in a separate file, e.g.,
strings are defined in
theres/values/strings.xmlfile.
Layouts /res/layout XML files with layout descriptions
are used to define the user
interface forActivitiesand
fragments.
Styles and Themes /res/values Files which define the appearance
of your Android application.
Animations /res/animator Defines animations in XML for the
animation API which allows to
animate arbitrary properties of
objects over time.
Raw data /res/raw Arbitrary files saved in their raw
form. You access them via
anInputStreamobject.
Menus /res/menu Defines the properties of entries
for a menu.
 7.2. Example: Defining strings, string arrays, colors and dimensions

The following listing is an example for file called values.xml in the /res/values which defines a
few String constants, a String array, a color and a dimension.

<?xml version="1.0" encoding="utf-8"?>

<resources>

<string name="app_name">Test</string>
<string name="action_settings">Settings</string>
<string name="hello_world">Hello world!</string>

<string-array name="operationsystems">
<item>Ubuntu</item>
<item>Android</item>
<item>Microsoft Windows</item>
</string-array>

<color name="red">#ffff0000</color>

<dimen name="mymargin">10dp</dimen>

</resources>
7.3. Resource qualifiers

You can also append additional qualifiers to the folder name to indicate that
the related resources should be used for special configurations. For example,
you can specify that layout file is only valid for a certain screen size.

7.4. Resource IDs and R.java

Every resource gets an ID assigned by the Android build system. The gen
directory in an Android project contains the R.java references file which
contains these generated values. These references are static integer values.

If you add a new resource file, the corresponding reference is automatically

created in a R.java file. Manual changes in the R.java file are not necessary
and will be overwritten by the tooling.

The Android system provides methods to access the corresponding resource

files via these IDs.

For example, to access a String with the R.string.yourString ID in your source

code, you would use the getString(R.string.yourString) method defined on the
Context class.
7.5. Good practices for resources IDs

The Android SDK uses the camelCase notation for most of its IDs,
e.g., buttonRefresh. It is good practice to follow this approach.

7.6. System resources

Android also provides resources. These are called system resources.

System resources are distinguished from local resources by the
android namespace prefix. For example, android.R.string.cancel
defines the platform string for a cancel operation.
8. Layout resource files

8.1. Activities and layouts

Android activities define their user interface with views (widgets) and
fragments. This user interface can be defined via XML layout resource files in
the /res/layout folder or via Java code. You can also mix both approaches.

Defining layouts via XML layout files is the preferred way. This separates the
programming logic from the layout definition. It also allows the definition of
different layouts for different devices.

8.2. XML layout files

A layout resource file is referred to as layout. A layout specifies the

ViewGroups, Views, their relationship and their attributes via an XML
representation.
The following code is an example for a simple layout file.

<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >

<TextView
android:id="@+id/mytext"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />

</RelativeLayout>
A layout is assigned to an activity via the setContentView() method
calls, as demonstrated in the following example code.

package com.issaclabs.android.first;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

}
8.3. Defining IDs

If a view needs to be accessed via Java code, you have to give the view a
unique ID via the android:id attribute. To assign a new ID to a view use
the android:id attribute of the corresponding element in the layout file.
The following shows an example in which a button gets the button1 ID
assigned via the android:id="@+id/button1" parameter.

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Show Preferences" >
</Button>

By conversion this statement creates a new ID if necessary in the R.java

file and assigns the defined ID to the corresponding view.
8.4. Good practice: Predefined IDs via a separate file

As described in the last section Android allows you to define IDs of user interface components dynamically in
the layout files. To have one central place to define ID, you can also define them in a configuration file.

To control your IDs, you can also create a file, typically called ids.xml, in your /res/values folder and
define your IDs in this file. The following listing shows an example for such a file.

<?xml version="1.0" encoding="utf-8"?>

<resources>
<item name="button1" type="id"/>
</resources>
This allows you to use the ID in your layout file.
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >
<Button
android:id="@id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:layout_marginRight="27dp"
android:text="Button" />

</RelativeLayout>
Warning : If you want to define the id in a separate file, you first need to
remove the @+id entries in your layout files, otherwise you get an error
messages that these files have already been created.

Note : While the above is good practice for real projects, the session of
ours avoid the usage of a separate id file as this setup is time consuming.
16.5. Performance considerations with layouts

Calculating the layout and drawing the views is a resource intensive

operation. You should use the simplest layout possible to achieve good
performance. For example, you should avoid nesting layout managers too
deeply or avoid using complex layout managers in case a simple layout
manager is sufficient.
9. Views

9.1. View class

A view in Android represents a widget, e.g., a button, or a layout

manager. The Android SDK provides standard views (widgets), e.g., via
the Button, TextView, EditText classes. It also includes complex widgets,
for example, ListView.

All views in Android extend the android.view.View class. This class is

relatively large (more than 18 000 lines of code) and provides a lot of
base functionality for subclasses.

The main packages for views are part of the android.view namespace for
all the base classes and android.widget for the default widgets of the
Android platform.
10. Layout Manager and ViewGroups

10.1. What is a layout manager?

A layout manager is a subclass of ViewGroup and is responsible for the

layout of itself and its child Views. Android supports different default
layout managers.

10.2. Important layout managers

As of Android 5.0 the most relevant layout managers are LinearLayout,

FrameLayout, RelativeLayout and GridLayout.

AbsoluteLayout is deprecated and TableLayout can be implemented more

effectively via GridLayout.

Warning RelativeLayout is a complex layout manager and should only be

used if such a complex layout is required, as it performs a resource
intensive calculation to layout its children.
10.3. Layout attributes

All layouts allow the developer to define attributes. Children can also define
attributes which may be evaluated by their parent layout.

Children can specify their desired width and height via the following attributes.

Table 5. Width and height definition

Attribute Description
android:layout_width Defines the width of the widget.
android:layout_height Defines the height of the widget.

Widgets can uses fixed sizes, e.g., with the dp definition, for example, 100dp.
While dp is a fixed size it will scale with different device configurations.
The match_parent value tells the application to maximize the widget in its parent.
The wrap_content value tells the layout to allocate the minimum amount so that
the widget is rendered correctly. The effect of these elements is demonstrated in
the following graphics.
10.4. FrameLayout

FrameLayout is a layout manager which draws all child elements on top of each
other. This allows to create nice visual effects.

10.5. LinearLayout

LinearLayout puts all its child elements into a single column or row depending
on the android:orientation attribute. Possible values for this attribute are
horizontal and vertical while horizontal is the default value.

If horizontal is used, the child elements are layouted as indicated by the

following picture.
Vertical would result in a layout as depicted in the following picture.

LinearLayout can be nested to achieve more complex layouts.

LinearLayout supports assigning a weight to individual children via the

android:layout_weight layout parameter. This value specifies how much of the extra
space in the layout is allocated to the View. If, for example, you have two widgets and
the first one defines a layout_weight of 1 and the second of 2, the first will get 1/3 of
the available space and the other one 2/3. You can also set the layout_width to zero to
always have a certain ratio.
10.6. RelativeLayout

RelativeLayout allows to position the widget relative to each other. This can be used
for complex layouts.

A simple usage for RelativeLayout is if you want to center a single component. Just
add one component to the RelativeLayout and set the android:layout_centerInParent
attribute to true. <?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/an
droid"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >

<ProgressBar
android:id="@+id/progressBar1"
style="?android:attr/progressBarStyleLarge"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
/>

</RelativeLayout>
18.7. GridLayout

GridLayout was introduced with Android 4.0. This layout allows you to organize a view into a Grid.
GridLayout separates its drawing area into: rows, columns, and cells.

You can specify how many columns you want to define for each View, in which row and column it
should be placed as well as how many columns and rows it should use. If not specified, GridLayout
uses defaults, e.g., one column, one row and the position of a View depends on the order of the
declaration of the Views.

The following layout file defines a layout using GridLayout.

<?xml version="1.0" encoding="utf-8"?>
<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/GridLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:columnCount="4"
android:useDefaultMargins="true" >

<TextView
android:layout_column="0"
android:layout_columnSpan="3"
android:layout_gravity="center_horizontal"
android:layout_marginTop="40dp"
android:layout_row="0"
android:text="User Credentials"
android:textSize="32dip" />

<TextView
android:layout_column="0"
android:layout_gravity="right"
android:layout_row="1"
android:text="User Name: " >
</TextView>
<EditText
android:id="@+id/input1"
android:layout_column="1"
android:layout_columnSpan="2"
android:layout_row="1"
android:ems="10" />
<TextView
android:layout_column="0"
android:layout_gravity="right"
android:layout_row="2"
android:text="Password: " ></TextView>
<EditText
android:id="@+id/input2"
android:layout_column="1"
android:layout_columnSpan="2"
android:layout_row="2"
android:inputType="textPassword"
android:ems="8" />
<Button
android:id="@+id/button1"
android:layout_column="2"
android:layout_row="3"
android:text="Login" />
</GridLayout>
This creates a user interface similar to the following
screenshot.
10.8. ScrollView

The ScrollView class can be used to contain one View that might be to big to fit on one screen. In
this case ScrollView will display a scroll bar to scroll the context.

Of course this View can be a layout which can then contain other elements.

The following code shows an example layout file which uses a ScrollView.
 <?xml version="1.0" encoding="utf-8"?>
<ScrollView
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fillViewport="true"
android:orientation="vertical" >

<TextView
android:id="@+id/TextView01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:paddingLeft="8dip"
android:paddingRight="8dip"
android:paddingTop="8dip"
android:text="This is a header"
android:textAppearance="?android:attr/textAppearanceLarge" >
</TextView>

</ScrollView>

The android:fillViewport="true" attribute ensures that the scrollview is set to

the full screen even if the elements are smaller than one screen.