BASIC OF

ANDROID
1. Introduction to Mobile Technologies

2. Introduction of Android

3. Android Building Blocks

4. Introduction of the Development tool “Eclipse”

5. Testing and Debugging Android Application

6. Android Activities

7. UI Design

8. Using Android system services

9. Database - SQLite

10. Broadcast
1. INTRODUCTION TO
MOBILE TECHNOLOGY
 INTRODUCTION TO MOBILE
TECHNOLOGIES

1.1 Background about mobile technologies

1.2 Why to use Android for mobile development?

 1.1 BACKGROUND ABOUT MOBILE
TECHNOLOGIES

• Mobile technology is the technology used for

cellular communication.

• Since the start of this millennium, a standard mobile

device has gone from being no more than a simple
two-way pager to being a mobile phone, GPS
navigation device, an embedded web
browser and instant messaging client, and
a handheld game console.
1.1 MOBILE TECHNOLOGY (CONTD.)

• Many types of mobile operating systems (OS) are

available for smartphones,
including: Android, BlackBerry
OS, IOS, Symbian, Windows Mobile and Bada. Among
the most popular are the Apple iPhone, and Android.
 ANDROID

• Android is an operating system based on Linux with

a Java programming interface.

• Android is a mobile operating system (OS)

developed by Google. Android is the first
completely open source mobile OS, meaning that it
is free to any cell phone carrier.

• Building on the contributions of the open-source

Linux community and more than 300 hardware,
software, and carrier partners, Android has rapidly
become the fastest-growing mobile OS.
 ANDROID VERSIONS

Version Codename API

1.6 Donut 4
2.1 Eclair 7
2.2 Froyo 8
2.3 - 2.3.2 9
Gingerbread
2.3.3 - 2.3.7 10
3.1 12
Honeycomb
3.2 13
Ice Cream
4.0.3 - 4.0.4 15
Sandwich
4.1 16
Jelly Bean
4.2 17
 ANDROID MARKET SHARE

• Android Dominates Worldwide Smartphone Market,

Powers 80 Percent Of All Smartphones Shipped In
Q2
 Mobile Application

• A mobile application (or mobile app) is a software

application designed to run on smartphones, tablet
computers and other mobile devices.
• Mobile apps were originally offered for general
productivity and information retrieval, including
email, calendar, contacts, and stock market and
weather information.
1.2 WHY TO USE ANDROID FOR MOBILE
DEVELOPMENT?
Objective-C vs. Android (Java)
• First and foremost, using Java is much better than
Objective-C. Private methods, inner classes,
anonymous classes, generics, better function
syntax, and a much wider plethora of 3rd-party
code are just a small smattering of the advantages
of Java.
• Objective-C doesn't provide a garbage collector
for iPhone while Java has lazy garbage collector
 WHY TO USE ANDROID FOR MOBILE
DEVELOPMENT? (CONTD.)

• You have more control and the power of Java

allows you to write stricter code that accomplishes
these tasks with better software methodologies.
2. INTRODUCTION OF
ANDROID
 2. INTRODUCTION OF ANDROID

2.1 What does Android run On – Android

Internals?

2.2 Introduction of DVM (Dalvic Virtual

Machine)

2.3 Architecture of Android

 2. INTRODUCTION OF
ANDROID
2.1 WHAT DOES ANDROID RUN ON – ANDROID
INTERNALS?
2.1 WHAT DOES ANDROID RUN ON –
ANDROID INTERNALS?
 LINUX KERNEL

• Android runs on Linux

• Linux provides as well as:
• Hardware abstraction layer
• Application Framework
• Memory management
• Users never see Linux sub system
• The adb shell command opens Linux shell
 LIBRARIES

• Bionic, a super fast and small license-friendly libc

library optimized for embedded use.
• Surface Manager for composing window manager
with off-screen buffering.
• WebKit: library for fast HTML rendering
•
 DALVIK VM

Dalvik VM is Google’s implementation of Java

• Optimized for mobile devices.
• Key Dalvik differences:
• Register-based versus stack-based VM
• Dalvik runs .dex files
• More efficient and compact implementation
• Different set of Java libraries than SDK
 APPLICATION FRAMEWORK

• Activation manager controls the life Applications

cycle of the app
• Content providers encapsulate data Application
Framework that is shared (e.g. contacts)
• Resource manager manages everything that is not
the code.
• Notification manager for events such as arriving
messages, appointments, etc.
 APPLICATION

• Each Android application runs inside its own Linux

process.
• Additionally, each application has its own sandbox
file system with its own set of preferences and its
own database.
• Other applications cannot access any of its
data,unless it is explicitly shared.
•
 APPLICATION(CONTD)

• There are three main scenarios for your app to talk

to native library:
• - Directly
• - Via native service
• - Via native daemon
• It will depend on the type of app and type of native
library which method works best.
APPLICATION FLOW
 INTRODUCTION OF
ANDROID
2.2 INTRODUCTION OF DVM (DALVIC VIRTUAL
MACHINE)
 2.2 INTRODUCTION OF DVM (DALVIC
VIRTUAL MACHINE)
• Google developed Android and chose DVM for
several reasons. First, there were licensing issues with
most JVMs.
• DVM should be more efficient in terms of memory
usage and performance on a register-based
machine.
• DVM is also supposed to be more efficient when
running multiple instances of the DVM. Applications
are given their own instance. Hence, multiple active
applications require multiple DVM instances. Like
most Java implementations, the DVM has an
automatic garbage collector.
INTRODUCTION OF
ANDROID
2.3 ARCHITECTURE OF ANDROID
2.3 ARCHITECTURE OF ANDROID

Android Java

Java SE – AWT/Swing + Android API

 2.3 ARCHITECTURE OF ANDROID

• Many APIs are similars but you don't have all J2SE APIs.

• Many APIs are limited to Android (Contacts, Power Management,

Graphics...);

• No Swing, no JavaFX ... You must use XML to declare you GUI;

• you can use java jars (if they use only compatible APIs) but they are
converted into dalvik.

• Code is compiled into Dalvik opcodes (not java byte code);

3. ANDROID BUILDING
BLOCKS
 3. ANDROID BUILDING BLOCKS

3.1 Activity
3.2 Broadcast Receiver
3.3 Content Provider
3.4 Service
3.5 Introduction of Intent
 3. ANDROID BUILDING BLOCKS

Each building block is a different point through which the system

can enter your application. Not all components are actual
entry points for the user and some depend on each other, but
each one exists as its own entity and plays a specific role—
each one is a unique building block that helps define your
application's overall behavior.

Activities
Services
Content providers
Broadcast receivers
 3.1 ACTIVITY

• An Activity represents a single screen with a user

interface.

• An activity represents the visual representation of

an Android application.

• Activities use Views , i.e. user interface widgets as

for example buttons and fragments to create the
user interface and to interact with the user.
3.1 ACTIVITY
 3.2 SERVICES

• Services perform tasks without providing a user

interface. They can communicate with other
Android components and notify the user via the
notification framework in Android.

• Service is a component that runs in the background

to perform long-running operations or to perform
work for remote processes.

• A service does not provide a user interface.

 3.2 SERVICES (CONTD.)

• Note that services, like other application objects,

run in the main thread of their hosting process. This
means that, if your service is going to do any CPU
intensive (such as MP3 playback) or blocking (such
as networking) operations, it should spawn its own
thread in which to do that work
 3.3 CONTENT PROVIDER

• A content provider manages a shared set of application

data. You can store the data in the file system, an SQLite
database, on the web, or any other persistent storage
location your application can access.
• A content provider provides a structured interface to
application data. Via a content provider your
application can 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 content provider
 3.4 BROADCAST RECEIVER

• Broadcast receivers can be registered to receive

messages and intents which could be system
generated or application level .

• A broadcast receiver gets notified by the Android

system, if the specified event occurs.

• For example you can register a broadcast receivers

for the event that the Android system completed
the boot processor or for the event that the state of
the phone changes, e.g. someone is calling.
 3.5 INTRODUCTION TO INTENT

• Intents are asynchronous messages which allow the

application to request functionality from other Android
components, e.g. from services or activities

• An application can call a component directly ( explicit Intent )

or ask the Android system to evaluate registered components
based on the intent data ( implicit intents ). For example the
application could implement sharing of data via an Intent
and all components which allow sharing of data would be
available for the user to select. Applications register
themselves to an intent via an intent Filter

• Intents allow an Android application to start and to interact

with components from other Android applications.
4. INTRODUCTION DEVELOPMENT
TOOL “ECLIPSE”
 4. INTRODUCTION OF THE
DEVELOPMENT TOOL “ECLIPSE”

4.1 Download the latest or working version of

“Eclipse”
4.2 Introduction to Android Simulator
4.3 How to create project?
4.4 First Project “Hello World”
4.5 Introduction to solution components
 4.1 DOWNLOAD THE LATEST OR
WORKING VERSION OF “ECLIPSE”

• The Android SDK provides you the API libraries and

developer tools necessary to build, test, and debug
apps for Android.

• http://developer.android.com/sdk/index.html
 ANDROID DEVELOPMENT TOOLS

• Google provides the Android Development Tools (ADT)

to develop Android applications with Eclipse.
• ADT is a set of components (plug-ins) which extend the
Eclipse IDE with Android development capabilities.
• ADT contains all required functionalities to create,
compile, debug and deploy Android applications from
the Eclipse IDE. ADT also allows to create and start AVDs.
• The Android Development Tools (ADT) provides
specialized editors for resources files, e.g. layout files.
• These editors allow to switch between the XML
representation of the file and a richer user interface via
tabs on the bottom of the editor.
 4.2 INTRODUCTION TO ANDROID
SIMULATOR
• To define an Android Virtual Device (ADV) open the
• AVD Manager dialog via Window Android Virtual
Device Manager and press the New button
AVD CONTINUE
RUN AVD
RUN AVD (CONTINUE)
 4.3 HOW TO CREATE PROJECT?

• Create a very simple project

• Run it on a real device

• Run it on the emulator

• Examine its structure

 PACKAGE CONTENT

All source code here Java code for our activity

All non-code Generated Java code

resources Helps link resources to
Java code

Images Layout of the activity

Strings used in the

program

Android Manifest
52
4.4 FIRST PROJECT “HELLO WORLD”
Inherit
package com.example.helloandroid; from the
Activity
import android.app.Activity;
import android.os.Bundle; Class
import android.widget.TextView;
public class HelloAndroid extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView tv = new TextView(this);
tv.setText("Hello, Android – by hand");
setContentView(tv);
}
}
Set the view “by
hand” – from the
program
53
RUN IT!

54
 /RES/LAYOUT/MAIN.XML

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

<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/>
</LinearLayout>
Further redirection to
/res/values/strings.xml

55
 /RES/VALUES/STRINGS.XML

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

<resources>
<string name="hello">Hello World, HelloAndroid – by resources!</string>
<string name="app_name">Hello, Android</string>
</resources>

56
 HELLOANDROID.JAVA

package com.example.helloandroid;

import android.app.Activity;
import android.os.Bundle;
public class HelloAndroid extends Activity {

/** Called when the activity is first created. */

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Set the layout of the
view as described in
the main.xml layout
57
 /GEN/R.JAVA

package com.example.helloandroid;
public final class R {
public static final class attr {
}
public static final class drawable {
public static final int icon=0x7f020000;
}
public static final class id {
public static final int textview=0x7f050000;
}
public static final class layout {
public static final int main=0x7f030000;
}
public static final class string {
public static final int app_name=0x7f040001;
public static final int hello=0x7f040000;
}
}

58
RUN IT!

59
5. TESTING AND DEBUGGING
ANDROID APPLICATION
5. TESTING AND DEBUGGING ANDROID
APPLICATION

5.1 Role and Use of Dalvik Debug Monitor

Server (DDMS)
5.2 How to debug android application
5.3 Use of Step Filters, Breakpoints, Suspend
and Resume
5.4 How to use LogCat (Verbose, Debug, Info,
Warn, Error, Assert)
5.5 Use of Perspectives
 5.1 ROLE OF DDMS

• Android ships with a debugging tool called the

Dalvik Debug Monitor Server (DDMS), which
provides port-forwarding services, screen capture
on the device, thread and heap information on the
device, logcat, process, and radio state
information, incoming call and SMS spoofing,
location data spoofing, and more.
 5.2 HOW TO DEBUG ANDROID
APPLICATION
• On Android, every application runs in its own process,
each of which runs in its own virtual machine (VM). Each
VM exposes a unique port that a debugger can attach
to.
• When DDMS starts, it connects to adb. When a device is
connected, a VM monitoring service is created
between adb and DDMS, which notifies DDMS when a
VM on the device is started or terminated. Once a VM is
running, DDMS retrieves the VM's process ID (pid),
via adb, and opens a connection to the VM's debugger,
through the adb daemon (adbd) on the device. DDMS
can now talk to the VM using a custom wire protocol.
5.3 USE OF STEP FILTERS, BREAKPOINTS,
SUSPEND AND RESUME
 5.4 HOW TO USE LOGCAT (VERBOSE,
DEBUG, INFO, WARN, ERROR, ASSERT)
LOGCAT VIEW
5.5 USE OF PERSPECTIVES
6. ANDROID ACTIVITIES
 6. ANDROID ACTIVITIES

6.1 Android Activity Lifecycle

6.2 Using Intents to Launch the Activities

 ACTIVITY
• An Android activity is focused on a single
thing a user can do.
• Most applications have multiple activities

71
6.1 ANDROID ACTIVITY LIFECYCLE
 AN ACTIVITY : THREE STATES

• Resumed The activity is in the foreground of the screen

and has user focus. (This state is also sometimes referred
to as "running".)
• Paused Another activity is in the foreground and has
focus, but this one is still visible. That is, another activity is
visible on top of this one and that activity is partially
transparent or doesn't cover the entire screen. A paused
activity is completely alive (the Activity object is retained
in memory, it maintains all state and member
information, and remains attached to the window
manager), but can be killed by the system in extremely
low memory situations.

73
AN ACTIVITY : THREE STATES (CONTD.)

• Stopped The activity is completely obscured by

another activity (the activity is now in the
"background"). A stopped activity is also still alive
(the Activity object is retained in memory, it maintains
all state and member information, but
is not attached to the window manager). However, it
is no longer visible to the user and it can be killed by
the system when memory is needed elsewhere.
• If an activity is paused or stopped, the system can
drop it from memory either by asking it to finish
(calling its finish() method), or simply killing its process.
When the activity is opened again (after being
finished or killed), it must be created all over.
74
 TASKS AND BACK STACK

• Each activity should be designed around a

specific kind of action the user can perform and
can start other activities.
• For example, an email application might have
one activity to show a list of new email. When
the user selects an email, a new activity opens
to view that email.

75
 6.2 USING INTENT TO LAUNCH THE
ACTIVITIES
• Intent are asynchronous messages which allow the
application to request functionality from other Android
components, e.g. from services or activities

• An application can call a component directly (explicit Intent )

or ask the Android system to evaluate registered components
based on the intent data ( implicit intents). For example the
application could implement sharing of data via an intent
and all components which allow sharing of data would be
available for the user to select. Applications register
themselves to an intent via an intentFilter .

• Intents allow an Android application to start and to interact

with components from other Android applications.
 INTENT (CONTD.)

• There are separate methods for activating each type of

component:
• You can start an activity (or give it something new to do)
by passing Intent to startActivity() or
startActivityForResult() .
• You can start a service (or give new instructions to an
ongoing service) by passing an Intent tostartService(). Or
you can bind to the service by passing
an Intent to bindService().
• You can initiate a broadcast by passing an Intent to
methods like sendBroadcast(),sendOrderedBroadcast(),
or sendStickyBroadcast().
• You can perform a query to a content provider by
calling query() on a ContentResolver.
77
7. UI DESIGN
 7. UI DESIGN

7.1 Fundamental Android UI Design

7.2 Introducing Layouts

7.3 Different UI widgets available in Android

7.4 Event driven Programming in Android

 7.1 FUNDAMENTAL ANDROID UI
DESIGN
• Layouts is important for good Android application
design.

• We provide an overview of how layouts fit into the

Android application architecture.

• We also explore some of the specific layout controls

available for organizing application screen content
in a variety of interesting ways
 WHAT IS A LAYOUT?

• Android developers use the term layout to mean one of two

things. Both definitions apply to this tutorial, and are,
unfortunately used interchangeably in the Android
development community.

The two definitions of layout are:

• A type of resource that defines what is drawn on the screen.
Layout resources are stored as XML files in the /res/layout
resource directory for the application. A layout resource is
simply a template for a user interface screen, or portion of a
screen, and contain.
• A type of View class whose primary purpose is to organize
other controls. These layout classes (LinearLayout,
RelativeLayout, TableLayout, etc. ) are used to display child
controls, such as text controls or buttons or images on the
screen.
 7.2 INTRODUCING LAYOUTS

• Frame Layout
• Liner Layout
• Relative Layout
• Table Layout
 FRAMELAYOUT

• Frame layouts are one of the simplest layout types

used to organize controls within the user interface of
an Android application.

• They are used less often than some other layouts,

simply because they are generally used to display
only one view, or views which overlap.
 FRAMELAYOUT (CONTD.)
When to Use Frame Layouts

• The efficiency of a frame layout makes it a good

choice for screens containing few view controls
(home screens, game screens with a single canvas,
and the like).
• Sometimes other inefficient layout designs can be
reduced to a frame layout design that is more
efficient, while other times a more specialized
layout type is appropriate. Frame layouts are the
normal layout of choice when you want to overlap
views.
 LINER LAYOUT
• Linear layouts are one of the simplest and most
common types of layouts used by Android
developers to organize controls within their user
interfaces.

• The linear layout works much as its name implies: it

organizes controls linearly in either a vertical or
horizontal fashion.

• When the layout’s orientation is set to vertical, all

child controls within it are organized in a single
column; when the layout’s orientation is set to
horizontal, all child controls within it are organized in
a single row.
 LINER LAYOUT(CONTD.)

Some specific attributes apply to linear layouts. Some

of the most important attributes you’ll use with linear
layouts include:
• The orientation attribute (required), which can be
set to vertical or horizontal
• The gravity attribute (optional), which controls how
all child controls are aligned and displayed within
the linear layout (class: LinearLayout)
• The layout_weight attribute (optional, applied to
each child control) specifies each child control’s
relative importance within the parent linear layout
(class: LinearLayout.LayoutParams)
 LINER LAYOUT(CONTD.)

Also, general ViewGroup-style attributes apply to

linear layouts. These include:
• Generic Layout Parameters such as layout_height
(required) and layout_width (required)

• Margin Layout Parameters such as margin_top,

margin_left, margin_right and margin_bottom

• Layout Parameters such as layout_height and

layout_width (
 RELATIVE LAYOUT

• The relative layout works much as its name implies: it

organizes controls relative to one another, or to the
parent control itself.
• What does this mean?
It means that child controls, such as ImageView, TextView
,and Button controls, can be placed above, below, to the left
or right, of one another. Child controls can also be placed in
relation to the parent (the relative layout container), including
placement of controls aligned to the top, bottom, left or right
edges of the layout
 RELATIVE LAYOUT(CONTD.)
• Attributes that help configure a relative layout and its
child controls. Some specific attributes apply to relative
layouts-namely the child rules, including:
• Rules for child control centering within the parent layout,
including: center horizontally, center vertically, or both.
• Rules for child control alignment within the parent layout,
including: align with top, bottom, left or right edge of
another control.
• Rules for child control alignment in relation to other child
controls, including: align with top, bottom, left or right
edge.
• Rules for child control placement in relation to other
child controls, including: placement to the left or right of
a specific control, or above or below another control.
 RELATIVE LAYOUT(CONTD.)

Also, general ViewGroup-style attributes apply to

relative layouts. These include:

• Generic Layout Parameters such as layout_height

(required) and layout_width (required)

• Margin Layout Parameters such as margin_top,

margin_left, margin_right and margin_bottom

• Layout Parameters such as layout_height and

layout_width
 TABLE LAYOUT

• A table layout is exactly what you might expect: a

grid of made up of rows and columns, where a cell
can display a view control. From a user interface
design perspective, a TableLayout is comprised of
TableRow controls—one for each row in your table.
• The contents of a TableRow are simply the view
controls that will go in each “cell” of the table grid.
 TABLELAYOUT CONCERNS

• Although table layouts can be used to design entire

user interfaces, they usually aren’t the best tool for
doing so, as they are derived from LinearLayout
and not the most efficient of layout controls.
• If you think about it, a TableLayout is little more than
an organized set of nested LinearLayouts, and
nesting layouts too deeply is generally discouraged
for performance concerns.
• However, for data that is already in a format
suitable for a table, such as spreadsheet data,
table layout may be a reasonable choice.
7.3 DIFFERENT UI WIDGETS AVAILABLE
IN ANDROID
• Text View
• Edit Text
• List View
• Spinner
• Button
• Check Box
• Radio Button
• Scroll View
 TEXT VIEW

• Displays text to the user and optionally allows them

to edit it. A TextView is a complete text editor,
however the basic class is configured to not allow
editing.
 EDIT TEXT

• EditText is a thin veneer over TextView that

configures itself to be editable.
 LISTVIEW

• The display of elements in a lists is a very common

pattern in mobile applications. The user sees a list of
items and can scroll through them.

• ListView is a view group that displays a list of

scrollable items. The list items are automatically
inserted to the list using an Adapter that pulls
content from a source such as an array or
database query and converts each item result into
a view that's placed into the list.
LISTVIEW
 SPINNERS

• Spinners provide a quick way to select one value

from a set. In the default state, a spinner shows its
currently selected value. Touching the spinner
displays a dropdown menu with all other available
values, from which the user can select a new one.

99
 CHECK BOX

• Checkboxes allow the user to select one or more

options from a set. Typically, you should present
each checkbox option in a vertical list.

100
 RADIO BUTTONS

• Radio buttons allow the user to select one option

from a set. You should use radio buttons for
optional sets that are mutually exclusive if you
think that the user needs to see all available
options side-by-side.

101
 SCROLLVIEW

• The ScrollView class can be used to contain one

View that might be to big too fit on one screen.
ScrollView will is this case display a scroll bar to scroll
the context.
• A ScrollView is a FrameLayout, meaning you should
place one child in it containing the entire contents
to scroll; this child may itself be a layout manager
with a complex hierarchy of objects. A child that is
often used is a LinearLayout in a vertical orientation,
presenting a vertical array of top-level items that
the user can scroll through.
 TOGGLE BUTTONS

• A toggle button allows the user to change a setting

between two states.
• You can add a basic toggle button to your layout
with theToggleButton object

103
 EVENT DRIVEN PROGRAMMING IN
ANDROID
There is a simple truth:

• Android (and other smartphone) programming isn’t

like desktop programming.

• Android applications aren’t really applications at

all, they are more like plugins into an existing
application. They don’t own execution and they
really shouldn’t do anything in the UI thread if they
can help it.
7.4 EVENT DRIVEN PROGRAMMING IN
ANDROID
• At OS boot, a process called the Zygote is created.
This process waits for incoming requests for app
startups. Once it receives a request, it forks a VM
instance based on the Zygote VM itself. Thus every
app is its own process with it's own sandboxed VM.
• It is this VM process that starts the onCreate() (and
other relevant methods) which subsequently start
the app.
 8.1 MENUS

Menus are a common user interface component in

many types of applications. To provide a familiar
and consistent user experience, you should use
the Menu APIs to present user actions and other
options in your activities.

• Options menu and action bar

• Context menu and contextual action mode
• Popup menu

106
OPTIONS MENU AND ACTION BAR

The options menu is the primary collection of menu items

for an activity. It's where you should place actions that
have a global impact on the app, such as "Search,"
"Compose email," and "Settings.“

• On Android 3.0 and higher, items from the options menu

are presented by the action bar as a combination of on-
screen action items and overflow options. Beginning with
Android 3.0, theMenu button is deprecated (some
devices don't have one), so you should migrate toward
using the action bar to provide access to actions and
other options.

107
CONTEXT MENU AND CONTEXTUAL
ACTION MODE

A context menu is a floating menu that appears

when the user performs a long-click on an element.
It provides actions that affect the selected content
or context frame.

@2013 Training 108

 POPUP MENU

A popup menu displays a list of items in a vertical list

that's anchored to the view that invoked the menu.
It's good for providing an overflow of actions that
relate to specific content or to provide options for a
second part of a command.

109
 CREATING CONTEXTUAL MENUS

• A contextual menu offers actions that affect a specific

item or context frame in the UI. You can provide a
context menu for any view, but they are most often
used for items in a ListView, GridView, or other view
collections in which the user can perform direct actions
on each item.
There are two ways to provide contextual actions:
• floating context menu. A menu appears as a floating
list of menu items (similar to a dialog) when the user
performs a long-click (press and hold) on a view that
declares support for a context menu.
• In the contextual action mode. This mode is a system
implementation ofActionMode that displays
acontextual action bar at the top of the screen 110
 CREATING A POPUP MENU
• A PopupMenu is a modal menu anchored to a View.
It appears below the anchor view if there is room, or
above the view otherwise.
It's useful for:
• Providing an overflow-style menu for actions
that relate to specific content Note: This is not the
same as a context menu, which is generally for
actions that affect selected content. For actions that
affect selected content.
• Providing a second part of a command sentence
(such as a button marked "Add" that produces a
popup menu with different "Add" options).
• Providing a drop-down similar to Spinner that does
not retain a persistent selection. 111
 8.2 WHAT IS DIALOG?
HOW TO CREATE AN ALERT DIALOG?
• A dialog is a small window that prompts the user to
make a decision or enter additional information. A
dialog does not fill the screen and is normally used
for modal events that require users to take an
action before they can proceed.
 DIALOG
A dialog is a small window that prompts the user
to make a decision or enter additional
information. A dialog does not fill the screen and
is normally used for modal events that require
users to take an action before they can
proceed.
• AlertDialogA dialog that can show a title, up to
three buttons, a list of selectable items, or a
custom layout.
• DatePickerDialog or TimePickerDialogA dialog
with a pre-defined UI that allows the user to
select a date or time.

113
 DIALOG

• These classes define the style and structure for

your dialog, but you should use
a DialogFragment as a container for your dialog.
TheDialogFragment class provides all the
controls you need to create your dialog and
manage its appearance, instead of calling
methods on the Dialog object.

114
 CREATE AN ALERT DIALOG?
Creating alert dialog is very easy :

AlertDialog alertDialog = new AlertDialog.Builder(

AlertDialogActivity.this).create();

// Setting Dialog Title

alertDialog.setTitle("Alert Dialog");

// Setting Dialog Message

alertDialog.setMessage("Welcome to AndroidHive.info");

// Setting Icon to Dialog

alertDialog.setIcon(R.drawable.tick);

// Setting OK Button
alertDialog.setButton("OK", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
// Write your code here to execute after dialog closed
Toast.makeText(getApplicationContext(), "You clicked on OK", Toast.LENGTH_SHORT).show();
}
});

// Showing Alert Message

alertDialog.show();
 8.3 WHAT IS TOAST IN ANDROID?

• A toast provides simple feedback about an

operation in a small popup.

• It only fills the amount of space required for the

message and the current activity remains visible
and interactive.
 TOAST(CONTD.)

Sample Code :

Context context = getApplicationContext();

CharSequence text = "Hello toast!";
int duration = Toast.LENGTH_SHORT;

Toast toast = Toast.makeText(context, text, duration);

toast.show();
 8.4 LIST VIEW

• ListView is a view group that displays a list of

scrollable items.
• The list items are automatically inserted to the list
using an Adapter that pulls content from a source
such as an array or database query and converts
each item result into a view that's placed into the
list
 ADAPTERS

• An Adapter acts as a bridge between an ListView

and the underlying data for that view.

• The Adapter provides access to the data items.

• The Adapter is also responsible for making a View

for each item in the data set

System/Native Adapter available in Android

• ArrayAdapter
• CursorAdapter
• SimpleCursorAdapter
 ARRAYADAPTER

• A concrete BaseAdapter that is backed by an array

of arbitrary objects.

• By default this class expects that the provided

resource id references a single TextView.

• If you want to use a more complex layout, use the

constructors that also takes a field id. That field id
should reference a TextView in the larger layout
resource
 CURSORADAPTER

• Adapter that exposes data from a Cursor to a

ListView widget. The Cursor must include a column
named "_id" or this class will not work
 SIMPLECURSOR ADAPTER

• An easy adapter to map columns from a cursor to

TextViews or ImageViews defined in an XML file.

• You can specify which columns you want, which

views you want to display the columns, and the XML
file that defines the appearance of these views.
 8.5 NOTIFICATION MANAGER

• Class to notify the user of events that happen. This is

how you tell the user that something has happened
in the background.

Notifications can take different forms:

• A persistent icon that goes in the status bar and is
accessible through the launcher, (when the user
selects it, a designated Intent can be launched),
• Turning on or flashing LEDs on the device, or
• Alerting the user by flashing the backlight, playing a
sound, or vibrating.
 NOTIFICATION MANAGER

• Each of the notify methods takes an int id parameter

and optionally a String tag parameter, which may
be null.

• These parameters are used to form a pair (tag, id), or

(null, id) if tag is unspecified. This pair identifies this
notification from your app to the system, so that pair
should be unique within your app.

• If you call one of the notify methods with a (tag, id) pair
that is currently active and a new set of notification
parameters, it will be updated
 8.6 PENDING INTENT

• A PendingIntent is a token that you give to a foreign

application (e.g. NotificationManager, AlarmManager,
Home Screen AppWidgetManager, or other 3rd party
applications), which allows the foreign application to
use your application's permissions to execute a
predefined piece of code.

• If you give the foreign application an Intent, and that

application sends/broadcasts the Intent you gave, they
will execute the Intent with their own permissions. But if
you instead give the foreign application a PendingIntent
you created using your own permission, that application
will execute the contained Intent using your application's
permission.
 8.7 NOTIFICATION

• A notification is a message you can display to

the user outside of your application's normal UI.
When you tell the system to issue a notification, it
first appears as an icon in the notification area.
To see the details of the notification, the user
opens the notification drawer.

126
 • A notification in normal view appears in an area that's
up to 64 dp tall. Even if you create a notification with a
big view style, it will appear in normal view until it's
expanded. This is an example of a normal view:
The callouts in the illustration refer to the following:
1. Content title
2. Large icon
3. Content text
4. Content info
5. Small icon
6. Time that the notification was issued. You can set an
explicit value with setWhen(); if you don't it defaults to
the time that the system received the notification. 127
9. USING ANDROID
SYSTEM SERVICES
 9. SERVICE INTRO

• A Service is a component which runs in the

background, without interacting with the user.
• Services support true multitasking for Android, as
they can run in their own process.
• If you use threads in Activities their are still
connected to the life-cycle of Activities and the
Android system may decide to terminate them at
any point in point.
• You can declare your own Service to perform long
running operations without user interaction or to
supply functionality to other applications.

129
 SERVICE INTRO(CONTD.)

• A Service needs to be declared in

the AndroidManifest.xml via a <service
android:name="yourclasss"> </service> and the
implementing class must extend theService class
or one of its subclasses.

• A Service will not automatically run in its own

thread. Without the process attribute, they run the
main thread of their hosting process. Therefore
you should run performance intensive tasks in the
background.

130
 RUNNING A SERVICES IN ITS OWN
PROCESS
• You can also specify that your Service runs in a
separate process via the
android:process =":process_description" attribute.
• This way the service gets its own process and has its
own memory. Any long running operation in
theService, e.g. a garbage collection, will not affect
the user interface of your Activity.
• The colon prefix before the name tells Android that
the Service is private to its declaring application. If
the colon is not used the Service would be a global
process and can be used by other components.

131
 • <service
android:name="WordService"
android:process=":my_process"
android:icon="@drawable/icon"
android:label="@string/service_name" >
</service>
• The colon prefix before the name tells Android that
the Service is private to its declaring application. If
the colon is not used the Service would be a global
process and can be used by other components.
• Additionally, you can ensure that your service is
private to your application only if you include
theandroid:exported attribute and set it to "false".

132
 FORMS OF SERVICE

• Started: A service is "started" when an application

component (such as an activity) starts it by
calling startService(). Once started, a service can run
in the background indefinitely, even if the
component that started it is destroyed. Usually, a
started service performs a single operation and does
not return a result to the caller.
• Bound :A service is "bound" when an application
component binds to it by calling bindService(). A
bound service offers a client-server interface that
allows components to interact with the service, send
requests, get results, and even do so across processes
with interprocess communication (IPC). A bound
service runs only as long as another application
component is bound to it. 133
 INTENTSERVICE

• The IntentService is used to perform a certain task in

the background. Once done, the instance of
IntentService terminate itself automatically.
Examples for its usage would be to download a
certain resources from the Internet.

• The IntentService class offers

the onHandleIntent() method which will be
asynchronously called by the Android system.

134
 SERVICE LIFECYCLE

To stop the service when

its work is done, by
calling stopSelf() orstopS
ervice().
135
 SERVICE LIFECYCLE

• onCreate()The system calls this method when the service is first

created, to perform one-time setup procedures (before it calls
eitheronStartCommand() or onBind())

• onStartCommand()The system calls this method when another

component, such as an activity, requests that the service be
started, by calling startService().

• onBind()The system calls this method when another component

wants to bind with the service (such as to perform RPC), by
callingbindService().

• onDestroy()The system calls this method when the service is no

longer used and is being destroyed. Your service should implement
this to clean up any resources such as threads, registered listeners,
receivers, etc
 SERVICE (CONTD.)

• Just like an activity, a service can define intent

filters that allow other components to invoke the
service using implicit intents. By declaring intent
filters, components from any application
installed on the user's device can potentially start
your service if your service declares an intent
filter that matches the intent another application
passes to startService().

• An application component such as an activity

can start the service by calling startService() and
passing an Intent that specifies the service and
includes any data for the service to use. The
service receives this Intent in
the onStartCommand() method. 137
10. DATABASE - SQLITE
 10. DATABASE - SQLITE

10.1 Introducing SQLite

10.2 SQLiteOpenHelper and creating a
database
10.3 Opening and closing a database
10.4 Working with cursors Inserts, updates, and
deletes
 10.1 DATABASE - SQLITE

• SQLite is an Open Source database.

• SQLite supports standard relational database

features like SQL syntax, transactions and prepared
statements. The database requires limited memory
at runtime (approx. 250 KByte) which makes it a
good candidate from being embedded into other
runtimes.
 SQLITE IN ANDROID

• SQLite is embedded into every Android device. Using an

SQLite database in Android does not require a setup
procedure or administration of the database.

• You only have to define the SQL statements for creating

and updating the database. Afterwards the database is
automatically managed for you by the Android
platform.

• Access to an SQLite database involves accessing the file

system. This can be slow. Therefore it is recommended to
perform database operations asynchronously

• If your application creates a database, this database is

by default saved in the
directoryDATA/data/APP_NAME/databases/FILENAME.
 10.2 SQLITEOPENHELPER AND
CREATING A DATABASE
• To create and upgrade a database in your Android
application you create a subclass of the
SQLiteOpenHelper class. In the constructor of your
subclass you call the super() method of
SQLiteOpenHelper, specifying the database name
and the current database version
 SQLITEOPENHELPER

In this class you need to override the following

methods to create and update your database.

• onCreate() - is called by the framework, if the

database is accessed but not yet created.

• onUpgrade() - called, if the database version is

increased in your application code. This method
allows you to update an existing database schema
or to drop the existing database and recreate it via
the onCreate() method.
 SQLITEDATABASE

SQLiteDatabase is the base class for working with a SQLite

database in Android and provides methods to open, query,
update and close the database.

• More specifically SQLiteDatabase provides the insert(),

update() and delete() methods.

• In addition it provides the execSQL() method, which allows to

execute an SQL statement directly.

• The object ContentValues allows to define key/values. The key

represents the table column identifier and the value
represents the content for the table record in this column.
ContentValues can be used for inserts and updates of
database entries.
 SQLITEDATABASE

• Queries can be created via the rawQuery() and query()

methods or via the SQLiteQueryBuilder class .

• rawQuery() directly accepts an SQL select statement as

input.

• query() provides a structured interface for specifying the

SQL query.

• SQLiteQueryBuilder is a convenience class that helps to

build SQL queries.
 RAWQUERY()

rawQuery() Example
The following gives an example of a rawQuery() call.

• Cursor cursor =
getReadableDatabase().rawQuery("select * from
todo where _id = ?", new String[] { id });
 QUERY()

query() Example
The following gives an example of a query() call.

• return database.query(DATABASE_TABLE,
new String[] { KEY_ROWID, KEY_CATEGORY,
KEY_SUMMARY, KEY_DESCRIPTION }, null, null, null,
null, null);
 10.3 OPENING AND CLOSING A
DATABASE
SQLiteDatabase db = this.getWritableDatabase();
//Opening DatabaseConnection

ContentValues values = new ContentValues();

values.put(KEY_NAME, contact.getName()); // Contact Name
values.put(KEY_PH_NO, contact.getPhoneNumber());
// Contact Phone Number

// Inserting Row
db.insert(TABLE_CONTACTS, null, values);
db.close(); // Closing database connection
 WORKING WITH CURSORS INSERTS,
UPDATES, AND DELETES
Cursor
• A query returns a Cursor object. A Cursor represents the
result of a query and basically points to one row of the
query result. This way Android can buffer the query
results efficiently; as it does not have to load all data into
memory.

• To get the number of elements of the resulting query use

the getCount() method.

• To move between individual data rows, you can use the

moveToFirst() and moveToNext() methods. The
isAfterLast() method allows to check if the end of the
query result has been reached.
10.4 WORKING WITH CURSORS INSERTS,
UPDATES, AND DELETES
• Cursor provides typed get*() methods, e.g.
getLong(columnIndex), getString(columnIndex) to
access the column data for the current position of the
result. The "columnIndex" is the number of the column
you are accessing.

• Cursor also provides the getColumnIndexOrThrow(String)

method which allows to get the column index for a
column name of the table.

• A Cursor needs to be closed with the close() method

call.
 INSERT

ContentValues values = new ContentValues();

values.put(MySQLiteHelper.COLUMN_COMMENT,
comment);
long insertId =
database.insert(MySQLiteHelper.TABLE_COMMENTS,
null, values);
cursor.close();
return newComment;
 DELETE

database.delete(MySQLiteHelper.TABLE_COMMENTS,
MySQLiteHelper.COLUMN_ID + " = " + id, null);
 CONTENT PROVIDER AND SHARING
DATA
• A SQLite database is private to the application which
creates it. If you want to share data with other
applications you can use a content provider.

• A content provider allows applications to access data.

In most cases this data is stored in an SQlite database.

• While a content provider can be used within an

application to access data, its is typically used to share
data with other application. As application data is by
default private, a content provider is a convenient to
share you data with other application based on a
structured interface.

• A content provider must be declared in the

AndroidManifest.xml file.
ACCESSING A CONTENT PROVIDER

The access to a content provider is done via an URI.

The basis for the URI is defined in the declaration of the
ContentProvider in the AndroidManifest.xml file via the
android:authorities attribute.
• To create your own ContentProvider you have to
define a class which
extendsandroid.content.ContentProvider.
• You also declare your ContentProvider in
the AndroidManifest.xmlfile. This entry must specify
the android:authorities attribute which allows to
identify the ContentProvider. This authority is the basis
for the URI to access data and must be unique.
11. BROADCAST
 11 .BROADCAST

11.1 System broadcast

11.2 User defined broadcast

 BROADCAST

• A broadcast receiver (receiver) can be registered

to receive 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.
 BROADCAST

• A receiver can be registered via the AndroidManifest.xml

file.

• Alternatively to this static registration, you can also register

a broadcast receiver dynamically via the
Context.registerReceiver() method.

• The implementing class for a receiver extends the

BroadcastReceiver class.

• If the event for which the broadcast receiver has registered

happens the onReceive() method of the receiver is called
by the Android system.
LIFECYCLE OF A BROADCAST RECEIVER

• After the onReceive() of the BroadcastReceiver has

finished, the Android system can recycle the
BroadcastReceiver.

• Before API 11 you could not perform any

asynchronous operation in the onReceive() method
because once the onReceive() method is finished
the Android system was allowed to recyled that
component. If you have potentially long running
operations you should trigger a service for that
 11.1 SYSTEM BROADCAST

• Several system events are defined as final static fields in the

Intent class. Other Android system classes also define events,
e.g. the TelephonyManager defines events for the change of
the phone state.

The following table lists a few important system events.

• Intent.ACTION_BOOT_COMPLETED : Boot completed.

Requires the android.permission.RECEIVE_BOOT_COMPLETED
permission.
• Intent.ACTION_POWER_CONNECTED : Power got
connected to the device.
• Intent.ACTION_POWER_DISCONNECTED : Power got
disconnected to the device.
• Intent.ACTION_BATTERY_LOW : Battery gets low, typically
used to reduce activities in your app which consume power.
• Intent.ACTION_BATTERY_OKAY : Battery status good again.
 11.2 USER DEFINED BROADCAST
• You can register a receiver for your own customer
actions.

The following AndroidManifest.xml file shows a

broadcast receiver which is registered to a custom
action.
<receiver android:name="MyReceiver" > <intent-filter>
<action
android:name="de.vogella.android.mybroadcast" />
</intent-filter> </receiver>
 SENDING BROADCAST INTENTS
The sendBroadcast() method from the Context class allows you to send
intents to your registered receivers. The following coding show an example.

Intent intent = new Intent();

intent.setAction("de.vogella.android.mybroadcast");
sendBroadcast(intent);

// handler for received Intents for the "my-event" event private

BroadcastReceiver mMessageReceiver = new BroadcastReceiver()
{
@Override
public void onReceive(Context context, Intent intent)
{ // Extract data included in the Intent String message =
intent.getStringExtra("message"); Log.d("receiver", "Got message: " +
message);
}
};