Mobile Application Development-Android

Abstract:
Mobile application development is the set of processes and procedures involved in writing application
software for small, wireless computing devices such as smart-phones or tablets. These applications are either preinstalled on phones during manufacture, or downloaded by customers from various mobile software distribution
platforms.
Mobile application development is similar to Web application development and has its roots in more traditional
software development. One critical difference, however, is that mobile applications (apps) are often written
specifically to take advantage of the unique features a particular mobile device offers. For instance, a gaming app
might be written to take advantage of the Android's accelerometer.
Android is a software stack for mobile devices that includes an operating system, middleware and key
applications. The Android SDK provides the tools and APIs necessary to begin developing applications on the
Android platform using the Java programming language.
This paper describes how to create Android applications with Eclipse. It is based on Eclipse 3.6 (Helios), Java 1.6
and Android 2.3.3 (Gingerbread).

Introduction:
Android is an open source and free mobile platform built on Linux kernel and backed by the strong consumer
brand of Google. Google announced the formation of the Open Handset Alliance (OHA) in Nov 2007 to further the
development of Android. OHA includes 45 diverse companies (mobile operators, handset manufacturers,
semiconductor companies, commercialization companies, and software companies). Android was open sourced
as a project in Oct 2008.

1. Android Operation System

Android is an operating system based on Linux with a Java programming interface. It provides tools, e.g. a
compiler, debugger and a device emulator as well as its own Java Virtual machine (Dalvik Virtual Machine DVM). Android uses a special virtual machine, e.g. the Dalvik Virtual Machine. Dalvik uses special byte code.
Therefore you cannot run standard Java byte code on Android. Android provides a tool "dx" which allows to
convert Java Class files into "dex" (Dalvik Executable) files. Android applications are packed into an .apk (Android
Package) file by the program "aapt" (Android Asset Packaging Tool). To simplify development Google provides the
Android Development Tools (ADT) for Eclipse. The ADT performs automatically the conversion from class to dex
files and creates the apk during deployment.
Android supports 2-D and 3-D graphics using the OpenGL libraries and supports data storage in a SQLite database.

1.1. Important Android components

An Android application consists out of the following parts:
Activity - Represents the presentation layer of an Android application, e.g. a screen which the user sees. An
Android application can have several activities and it can be switched between them during runtime of the
application.
Views - The User interface of Activities is build with widgets classes which inherent from "android.view.View".
The layout of the views is managed by "android.view.ViewGroups".

Services - perform background tasks without providing an UI. They can notify the user via the notification
framework in Android.
Content Provider - provides data to applications, via a content provider your application can share data with
other applications. Android contains a SQLite DB which can serve as data provider
Intents are asynchronous messages which allow the application to request functionality from other services or
activities. An application can call directly a service or activity (explicit intent) or ask the Android system for
registered services and applications for intent (implicit intents).
Broadcast Receiver - receives system messages and implicit intents, can be used to react to changed conditions in
the system. An application can register as a broadcast receiver for certain events and can be started if such an
event occurs.

1.2. Security and permissions

Android defines certain permissions for certain tasks. For example if the application want to access the Internet it
must define in its configuration file that it would like to use the related permission. During the installation of an
Android application the user get a screen in which he needs to confirm the required permissions of the
application.

1.3. AndroidManifest.xml
An Android application is described by the file "AndroidManifest.xml". This file must declare all activities, services,
broadcast receivers and content provider of the application. It must also contain the required permissions for the
application. For example if the application requires network access it must be specified here.
"AndroidManifest.xml" can be thought as the deployment descriptor for an Android application.
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="myandroid.hello"
android:versionCode="1"
android:versionName="1.0">
<uses-sdk android:minSdkVersion="10" />
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".Hello"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

The "package" attribute defines the base package for the following Java elements. It also must be unique as the
Android Marketplace only allows application for a specific package once. Therefore a good habit is to use your
reverse domain name as a package to avoid collisions with other developers.
"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 and the Android Market uses this to
determine if you provided a newer version to trigger the update on devices which have your application installed.
You typically start with "1" and increase this value by one if you roll-out a new version of your application.
"activity" defines an activity in this example pointing to the class "de.vogella.android.temperature.Convert". For
this class an intent filter is registered which defines that this activity is started once the application starts (action

android:name="android.intent.action.MAIN").
The
category
definition
(category
android:name="android.intent.category.LAUNCHER" ) defines that this application is added to the application
directory on the Android device. The @ values refer to resource files which contain the actual values. This makes
it easy to provide different resources, e.g. strings, colors, icons, for different devices and makes it easy to
translate applications.
The "uses-sdk" part of the "AndroidManifest.xml" defines the minimal SDK version your application is valid for.
This will prevent your application being installed on devices with older SDK versions.

1.4. R.java, Resources and Assets

The directory "gen" in an Android project contains generated values. "R.java" is a generated class which contains
references to resources of the "res" folder in the project. These resources are defined in the "res" directory and
can be values, menus, layouts, icons or pictures or animations. For example a resource can be an image or an XML
files which defines strings.
If you create a new resources, the corresponding reference is automatically created in "R.java". The references
are static int values, the Android system provides methods to access the corresponding resource. For example to
access a String with the reference id "R.string.yourString" use the method getString(R.string.yourString)); Please
do not try to modify "R.java" manually.
While the directory"res" contains structured values which are known to the Android platform the directory
"assets" can be used to store any kind of data. In Java you can access this data via the AssetsManager and the
method getAssets().

1.5. Activities and Layouts

The user interface for Activities is defined via layouts. Layouts are at runtime instances of
"android.view.ViewGroups". The layout defines the UI elements, their properties and their arragement. UI
elements are based on the class "android.view.View". ViewGroup is a subclass of View A and a layout can contain
UI components (Views) or other layouts (ViewGroups). You should not nestle ViewGroups to deeply as this has a
negative impact on performance.
A layout can be defined via Java code or via XML. You typically uses Java code to generate the layout if you don't
know the content until runtime; for example if your layout depends on content which you read from the internet.
XML based layouts are defined via a resource file in the folder "/res/layout". This file specifies the view groups,
views, their relationship and their attributes for a specific layout. If a UI element needs to be accessed via Java
code you have to give the UI element an unique id via the "android:id" attribute. To assign a new id to an UI
element use "@+id/yourvalue". By conversion this will create and assign a new id "yourvalue" to the
corresponding UI element. In your Java code you can later access these UI elements via the method
findViewById(R.id.yourvalue).
Defining layouts via XML is usually the preferred way as this separates the programming logic from the layout
definition. It also allows to define different layouts for different devices. You can also mix both approaches.

1.6. Activities and Lifecycle

The operating system controls the life cycle of your application. At any time the Android system may stop or
destroy your application, e.g. because of an incoming call. The Android system defines a life cycle for an activity
via pre-defined methods. The most important methods are:

onSaveInstanceState() - called if the activity is stopped. Used to save data so that the activity can restore its states
if re-started
onPause() - always called if the Activity ends, can be used to release resource or save data
onResume() - called if the Activity is re-started, can be used to initialize fields
The activity will also be restarted if a so called "configuration change" happens. A configuration change for
examples happens if the user changes the orientation of the device (vertical or horizontal). The activity is in this
case restarted to enable the Android platform to load different resources for these configuration, e.g. layouts for
vertical or horizontal mode. In the emulator you can simulate the change of the orientation via CNTR+F11.

1.7. Context
The class android.content.Context provides the connections to the Android system. It is the interface to global
information about the application environment. Context also provides the method which allows to receive
Android services, e.g. the Location Service. As Activities and Services extend the class "Context" you can directly
access the context via "this".

Conclusion:
The Android mobile phone market is growing at an impressive rate of 32 per cent every month, with new
handsets being released all the time. Industry experts believe the boom owes much to the popularity of the
Motorola Droid, MotoBLUR, certain HTC models, and the opensource nature of the OS. As a new wave in the
crowded mobile market, Android Mobile Development is an important aspect in developing mobile applications
using the software stack provided in the Google Android SDK. The use of Androidbased smartphones is booming,
with more than 50,000 and android applications being already developed. Android is java based environment.
Android is proliferating rapidly due to open, fast and easy development of applications. Developers write
managed code in Java language using Android Java libraries. Android is not limited to mobile applications. Android
can be used in consumer electronic devices, net books, automotive units, among other devices. Phones from
Google, Motorola, AT&T, Sprint-Nextel, and Verizon-Wireless run on the Android platform. Broadcom have
ported Android to their advanced navigation processor. MIPS Technologies have ported Android to their 32-bit
version of the MIPS architecture. This architecture is used in set-top boxes, digital TV sets, home media players,
Internet telephony systems and mobile internet devices (MIDs). Intel has demonstrated an Atombased Net book
running Google's Android operating system at Computex. CES 2010 showcased set top boxes and automotive
units which use Android.

References:
Learn Java for Android Development- Jeff Friesen
http://developer.android.com
http://www.wikipedia.org/
http://www.devx.com/wireless/Article/39101/1954?pf=true