Introduction of Mobile Applications

Talking about the mobile applications, the first thing that comes to mind are the
apps like Whatsapp, Instagram, swiggy, etc that we use in our everyday life.
Ever thought about how these apps are made? Which technology is used? Let’s
discuss what technologies or frameworks can be used to develop a mobile
application. Mobile apps are majorly developed for 3 Operating System. :
1. Android
2. IOS
3. Windows
There are 3 different ways to develop Mobile apps: –
1. 1st Party Native App development
2. Progressive web Application
3. Cross-Platform Application
 1. 1st Party Native App development : –
These types of apps normally run in the native devices, that is, it runs only in
the OS that it is specifically designed for it. These apps cannot be used on
different devices using a different OS. The apps that are developed for
android are normally coded using Java or Kotlin languages. The IDE normally
used for android app development is Android Studio which provides all features
and the apps that are developed for IOS are generally coded in Swift language
or Objective-C. The IDE suggested for IOS App Development is XCode.
Example,
Here’s an example of a 1st party native app:
A retail company wants to improve the in-store shopping experience for its
customers. They develop a 1st party native app that allows customers to:
 Browse the store’s inventory and product information
 Create a shopping list
 Scan barcodes to view product information and reviews
 Locate items in the store using an interactive map
 Pay for items directly through the app, without having to wait in line at the
register
 The app is only available to the company’s customers and can only be used
in their physical stores. The app is designed to integrate with the company’s
existing systems, such as inventory management and point-of-sale systems.
 This app is developed by the retail company for their own use, to improve
the in-store customer experience, increase sales and gain insights from
the customer’s behavior.
 In this example, the retail company is the 1st party, and the app is a
native app, because it is developed for the specific platform (iOS or
 Android) and can take full advantage of the device’s capabilities and
features.
 Advantages of 1st Party Native App development:
1. The performances of these apps are very high these apps very fast
compared to any other apps.
2. We have easy access to all the features and APIs.
3. The community is widespread so all your doubts and errors can be
discussed and solved easily.
4. Updates are available on the same day.
Disadvantages of 1st Party Native App development:
1. The development speed is too slow as we have to code it again for different
OS.
2. And this category doesn’t support open source.
3. Progressive web Application : –
4. Progressive web apps are essentially a website which runs locally on
your device. The technologies used are Microsoft Blazor, React, Angular
JS, Native Script, Iconic. These technologies normally used for web
development propose. The apps’ UI is developed the same way as they
are developed while developing the website. This category has many ups
and downs let’s start with the advantages of Progressive web apps.
5. Example,
6. Here’s an example of a Progressive Web App:
7. A news website wants to provide its users with a better mobile
experience. They develop a Progressive Web App that:
8. Allows users to access the website offline by storing content on the user’s
device
9. Sends push notifications to users to alert them of breaking news
10. Can be installed on the user’s home screen like a native app
11. Provides a fast and smooth browsing experience
12. Has a responsive design that adapts to different screen sizes
13. Users can access the PWA by visiting the website on their mobile
browser. They are prompted to install the PWA on their home screen,
which allows them to access the website offline and receive push
notifications.
In this example, the news website is the 1st party and the app is a Progressive
web app, because it can be accessed through a web browser and can be
installed on the user’s device like a native app. It also allows users to access
the content offline and have a fast and smooth experience.
Advantages of Progressive web Application:
1. The main advantage of this process is that its development speed is fast the
same code base is used for IOS, Android, web applications.
2. The web development team can be repurposed to develop the mobile
application.
3. No installation required.
Disadvantages of Progressive web Application:
1. The major disadvantage is that PWA don’t have access to all the feature and
so the user experience is not that good IOS does not support all the features
of PWA
2. The UI for development is bespoke i.e. the buttons, edit texts need to be
programmed which was not necessary for the 1st party native Apps.
3. The community is not that wide spread.
4. No extra room for business model i.e. it is still a challenge to develop a
revenue model or advertising opportunities for PWAs. At the moment,
there are fewer options than among native apps to subscribe to.
3. Cross-Platform Application : –
These are frameworks that allow developing total native applications which
have access to all the native features of IOS and Android but with the same
code base. These apps run on both Android and IOS. So normally the
development speeds of these apps are very fast and the maintenance cost is
low. The performance speed is comparatively low to 1st party native apps but
faster than PWA.
Xamarin is Microsoft cross-platform solution that uses the programming
languages like .NET, C#, F#. The IDE preferred is Visual Studio. The UI/UX is
totally native giving access to all features. This technology is having a wide
community. And whenever an update is released by Android and IOS the same
updates are released by Microsoft through Visual Studio.
React Native is Facebook’s cross-platform solution which uses the language
JavaScript And the preferred IDE is WebStrome & Visual Studio Code. Same
like Xamarin React Native has totally native UI/UX and gives access to all
features. And the updates are released the same day by
Facebook as Android and IOS.
Flutter is Google’s cross-platform solution which uses the language, Dart.
The IDE preferred is Android Studio, IntelliJ IDE, and Visual Studio Code.
The UI/UX is bespoke and Flutters has to come up with their new libraries
whenever Android and IOS comes up with an update to mimic those
update. The community is fast growing. Example,
Here’s an example of a cross-platform application:
A project management company wants to create a project management tool
that can be used by teams on different platforms. They develop a cross-
platform application that:
 Can be used on Windows, Mac, iOS, and Android devices
 Allows users to create and assign tasks, set deadlines, and track
 progress
 Integrates with popular tools such as Google Calendar and Trello
 Has a user-friendly interface that works seamlessly across all platforms
 The application can be downloaded from the company’s website or from
different app stores such as App Store, Google Play Store, Microsoft
Store, and Mac App Store, depending on the platform.
This example illustrates how the company developed a project management
tool that can be used by teams on different platforms, Windows, Mac, iOS and
Android, which is a cross-platform application. It allows teams to collaborate
and manage their projects seamlessly,
regardless of the platform they use.
Advantages of Cross-Platform Application:
1. The apps’ development speed is very high as they use the same code base
for both Android and IOS.
2. The apps’ maintenance cost is low as the errors and updates as to be
countered only once.
Disadvantages of Cross-Platform Application:
1. Slow Code Performance With Limited Tool Availability.
2. Limited User Experience i.e. these apps does not have access to Native
only features.
What is Android?

Android is an open source and Linux-based Operating System for mobile devices such
as smartphones and tablet computers. Android was developed by the Open Handset
Alliance, led by Google, and other companies.
Android offers a unified approach to application development for mobile devices which
means developers need only develop for Android, and their applications should be able
to run on different devices powered by Android.
The first beta version of the Android Software Development Kit (SDK) was released by
Google in 2007 where as the first commercial version, Android 1.0, was released in
September 2008.
On June 27, 2012, at the Google I/O conference, Google announced the next Android
version, 4.1 Jelly Bean. Jelly Bean is an incremental update, with the primary aim of
improving the user interface, both in terms of functionality and performance.
The source code for Android is available under free and open source software licenses.
Google publishes most of the code under the Apache License version 2.0 and the rest,
Linux kernel changes, under the GNU General Public License version 2.
Why Android ?

Features of Android
Android is a powerful operating system competing with Apple 4GS and supports great features.
Few of them are listed below −

Sr.No. Feature & Description

1
Beautiful UI
Android OS basic screen provides a beautiful and intuitive user interface.

2
Connectivity
GSM/EDGE, IDEN, CDMA, EV-DO, UMTS, Bluetooth, Wi-Fi, LTE, NFC and
WiMAX.

3
Storage
 SQLite, a lightweight relational database, is used for data storage purposes.

4
Media support
H.263, H.264, MPEG-4 SP, AMR, AMR-WB, AAC, HE-AAC, AAC 5.1, MP3, MIDI,
Ogg Vorbis, WAV, JPEG, PNG, GIF, and BMP.

5
Messaging
SMS and MMS

6
Web browser
Based on the open-source WebKit layout engine, coupled with Chrome's V8 JavaScript
engine supporting HTML5 and CSS3.

7
Multi-touch
Android has native support for multi-touch which was initially made available in
handsets such as the HTC Hero.

8
Multi-tasking
User can jump from one task to another and same time various application can run
simultaneously.

9
Resizable widgets
Widgets are resizable, so users can expand them to show more content or shrink them to
save space.

10
Multi-Language
Supports single direction and bi-directional text.

11
GCM
Google Cloud Messaging (GCM) is a service that lets developers send short message
data to their users on Android devices, without needing a proprietary sync solution.

12
Wi-Fi Direct
 A technology that lets apps discover and pair directly, over a high-bandwidth peer-to-
peer connection.

13
Android Beam
A popular NFC-based technology that lets users instantly share, just by touching two
NFC-enabled phones together.

Android Applications
Android applications are usually developed in the Java language using the Android Software
Development Kit.
Once developed, Android applications can be packaged easily and sold out either through a store
such as Google Play, SlideME, Opera Mobile Store, Mobango, F-droid and the Amazon
Appstore.
Android powers hundreds of millions of mobile devices in more than 190 countries around the
world. It's the largest installed base of any mobile platform and growing fast. Every day more
than 1 million new Android devices are activated worldwide.
This tutorial has been written with an aim to teach you how to develop and package Android
application. We will start from environment setup for Android application programming and
then drill down to look into various aspects of Android applications.

Categories of Android applications

There are many android applications in the market. The top categories are −
History of Android
The code names of android ranges from A to N currently, such as Aestro, Blender, Cupcake,
Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice Cream Sandwitch, Jelly Bean, KitKat,
Lollipop and Marshmallow. Let's understand the android history in a sequence.

What is API level?

API Level is an integer value that uniquely identifies the framework API revision offered by a
version of the Android platform.

Platform Version API Level VERSION_CODE

Android 6.0 23 MARSHMALLOW

Android 5.1 22 LOLLIPOP_MR1

Android 5.0 21 LOLLIPOP

Android 4.4W 20 KITKAT_WATCH KitKat for Wearables Only

Android 4.4 19 KITKAT

Android 4.3 18 JELLY_BEAN_MR2

Android 4.2, 4.2.2 17 JELLY_BEAN_MR1

Android 4.1, 4.1.1 16 JELLY_BEAN

Android 4.0.3, 4.0.4 15 ICE_CREAM_SANDWICH_MR1

Android 4.0, 4.0.1, 4.0.2 14 ICE_CREAM_SANDWICH

Android 3.2 13 HONEYCOMB_MR2

Android 3.1.x 12 HONEYCOMB_MR1

Android 3.0.x 11 HONEYCOMB

10 GINGERBREAD_MR1
Android 2.3.4
Android 2.3.3

9 GINGERBREAD
Android 2.3.2
Android 2.3.1
Android 2.3

Android 2.2.x 8 FROYO

Android 2.1.x 7 ECLAIR_MR1

Android 2.0.1 6 ECLAIR_0_1

Android 2.0 5 ECLAIR

Android 1.6 4 DONUT

Android 1.5 3 CUPCAKE

Android 1.1 2 BASE_1_1

Android 1.0 1 BASE

You will be glad to know that you can start your Android application development on
either of the following operating systems −
 Microsoft Windows XP or later version.
 Mac OS X 10.5.8 or later version with Intel chip.
 Linux including GNU C Library 2.7 or later.
Second point is that all the required tools to develop Android applications are freely
available and can be downloaded from the Web. Following is the list of software's you
will need before you start your Android application programming.
 Java JDK5 or later version
 Android Studio
Here last two components are optional and if you are working on Windows machine
then these components make your life easy while doing Java based application
development. So let us have a look how to proceed to set required environment.
Set-up Java Development Kit (JDK)
You can download the latest version of Java JDK from Oracle's Java site − Java SE
Downloads. You will find instructions for installing JDK in downloaded files, follow the
given instructions to install and configure the setup. Finally set PATH and JAVA_HOME
environment variables to refer to the directory that contains java and javac, typically
java_install_dir/bin and java_install_dir respectively.
If you are running Windows and installed the JDK in C:\jdk1.8.0_102, you would have to
put the following line in your C:\autoexec.bat file.
set PATH=C:\jdk1.8.0_102\bin;%PATH%
set JAVA_HOME=C:\jdk1.8.0_102
Alternatively, you could also right-click on My Computer, select Properties,
then Advanced, then Environment Variables. Then, you would update the PATH value
and press the OK button.
On Linux, if the SDK is installed in /usr/local/jdk1.8.0_102 and you use the C shell, you
would put the following code into your .cshrc file.
setenv PATH /usr/local/jdk1.8.0_102/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.8.0_102
Alternatively, if you use Android studio, then it will know automatically where you have
installed your Java.

Android IDEs
There are so many sophisticated Technologies are available to develop android
applications, the familiar technologies, which are predominantly using tools as follows
 Android Studio
 Eclipse IDE(Deprecated)
Android operating system is a stack of software components which is roughly divided
into five sections and four main layers as shown below in the architecture diagram.
Linux kernel
At the bottom of the layers is Linux - Linux 3.6 with approximately 115 patches. This
provides a level of abstraction between the device hardware and it contains all the
essential hardware drivers like camera, keypad, display etc. Also, the kernel handles all
the things that Linux is really good at such as networking and a vast array of device
drivers, which take the pain out of interfacing to peripheral hardware.

Libraries
On top of Linux kernel there is a set of libraries including open-source Web browser
engine WebKit, well known library libc, SQLite database which is a useful repository for
storage and sharing of application data, libraries to play and record audio and video,
SSL libraries responsible for Internet security etc.

Android Libraries
This category encompasses those Java-based libraries that are specific to Android
development. Examples of libraries in this category include the application framework
libraries in addition to those that facilitate user interface building, graphics drawing and
database access. A summary of some key core Android libraries available to the
Android developer is as follows −
  android.app − Provides access to the application model and is the cornerstone
of all Android applications.
 android.content − Facilitates content access, publishing and messaging
between applications and application components.
 android.database − Used to access data published by content providers and
includes SQLite database management classes.
 android.opengl − A Java interface to the OpenGL ES 3D graphics rendering
API.
 android.os − Provides applications with access to standard operating system
services including messages, system services and inter-process communication.
 android.text − Used to render and manipulate text on a device display.
 android.view − The fundamental building blocks of application user interfaces.
 android.widget − A rich collection of pre-built user interface components such as
buttons, labels, list views, layout managers, radio buttons etc.
 android.webkit − A set of classes intended to allow web-browsing capabilities to
be built into applications.
Having covered the Java-based core libraries in the Android runtime, it is now time to
turn our attention to the C/C++ based libraries contained in this layer of the Android
software stack.

Android Runtime
This is the third section of the architecture and available on the second layer from the
bottom. This section provides a key component called Dalvik Virtual Machine which is
a kind of Java Virtual Machine specially designed and optimized for Android.
The Dalvik VM makes use of Linux core features like memory management and multi-
threading, which is intrinsic in the Java language. The Dalvik VM enables every Android
application to run in its own process, with its own instance of the Dalvik virtual machine.
The Android runtime also provides a set of core libraries which enable Android
application developers to write Android applications using standard Java programming
language.

Application Framework
The Application Framework layer provides many higher-level services to applications in
the form of Java classes. Application developers are allowed to make use of these
services in their applications.
The Android framework includes the following key services −
 Activity Manager − Controls all aspects of the application lifecycle and activity
stack.
 Content Providers − Allows applications to publish and share data with other
applications.
 Resource Manager − Provides access to non-code embedded resources such
as strings, color settings and user interface layouts.
  Notifications Manager − Allows applications to display alerts and notifications to
the user.
 View System − An extensible set of views used to create application user
interfaces.
Applications
You will find all the Android application at the top layer. You will write your application to
be installed on this layer only. Examples of such applications are Contacts Books,
Browser, Games etc.
Application components are the essential building blocks of an Android application.
These components are loosely coupled by the application manifest
file AndroidManifest.xml that describes each component of the application and how they
interact.
There are following four main components that can be used within an Android
application −

Sr.No Components & Description

1 Activities
They dictate the UI and handle the user interaction to the smart phone screen.

2 Services
They handle background processing associated with an application.

3 Broadcast Receivers
They handle communication between Android OS and applications.

4 Content Providers
They handle data and database management issues.

Activities
An activity represents a single screen with a user interface,in-short Activity performs
actions on the screen. For example, an email application might have one activity that
shows a list of new emails, another activity to compose an email, and another activity
for reading emails. If an application has more than one activity, then one of them should
be marked as the activity that is presented when the application is launched.
An activity is implemented as a subclass of Activity class as follows −
public class MainActivity extends Activity {
}

Services
A service is a component that runs in the background to perform long-running
operations. For example, a service might play music in the background while the user is
in a different application, or it might fetch data over the network without blocking user
interaction with an activity.
A service is implemented as a subclass of Service class as follows −
public class MyService extends Service {
}

Broadcast Receivers
Broadcast Receivers simply respond to broadcast messages from other applications or
from the system. For example, applications can also initiate broadcasts to let other
applications know that some data has been downloaded to the device and is available
for them to use, so this is broadcast receiver who will intercept this communication and
will initiate appropriate action.
A broadcast receiver is implemented as a subclass of BroadcastReceiver class and
each message is broadcaster as an Intent object.
public class MyReceiver extends BroadcastReceiver {
public void onReceive(context,intent){}
}

Content Providers
A content provider component supplies data from one application to others on request.
Such requests are handled by the methods of the ContentResolver class. The data may
be stored in the file system, the database or somewhere else entirely.
A content provider is implemented as a subclass of ContentProvider class and must
implement a standard set of APIs that enable other applications to perform transactions.
public class MyContentProvider extends ContentProvider {
public void onCreate(){}
}
We will go through these tags in detail while covering application components in
individual chapters.

Additional Components
There are additional components which will be used in the construction of above
mentioned entities, their logic, and wiring between them. These components are −
 S.No Components & Description

1 Fragments
Represents a portion of user interface in an Activity.

2 Views
UI elements that are drawn on-screen including buttons, lists forms etc.

3 Layouts
View hierarchies that control screen format and appearance of the views.

4 Intents
Messages wiring components together.

5 Resources
External elements, such as strings, constants and drawable pictures.

6 Manifest
Configuration file for the application.

Let us start actual programming with Android Framework. Before you start writing your
first example using Android SDK, you have to make sure that you have set-up your
Android development environment properly as explained in Android - Environment Set-
up tutorial. I also assume that you have a little bit working knowledge with Android
studio.
So let us proceed to write a simple Android Application which will print "Hello World!".

Create Android Application

The first step is to create a simple Android Application using Android studio. When you
click on Android studio icon, it will show screen as shown below
You can start your application development by calling start a new android studio project.
in a new installation frame should ask Application name, package information and
location of the project.−
After entered application name, it going to be called select the form factors your
application runs on, here need to specify Minimum SDK, in our tutorial, I have declared
as API23: Android 6.0(Mashmallow) −
The next level of installation should contain selecting the activity to mobile, it specifies
the default layout for Applications.

At the final stage it going to be open development tool to write the application code.

Anatomy of Android Application

Before you run your app, you should be aware of a few directories and files in the
Android project −
Sr.No Folder, File & Description
.

Java
1 This contains the .java source files for your project. By default, it includes
an MainActivity.java source file having an activity class that runs when your app
is launched using the app icon.

2
res/drawable-hdpi
 This is a directory for drawable objects that are designed for high-density
screens.

3 res/layout
This is a directory for files that define your app's user interface.

res/values
4
This is a directory for other various XML files that contain a collection of
resources, such as strings and colours definitions.

AndroidManifest.xml
5
This is the manifest file which describes the fundamental characteristics of the
app and defines each of its components.

Build.gradle
6 This is an auto generated file which contains compileSdkVersion,
buildToolsVersion, applicationId, minSdkVersion, targetSdkVersion,
versionCode and versionName

Following section will give a brief overview of the important application files.

The Main Activity File

The main activity code is a Java file MainActivity.java. This is the actual application file
which ultimately gets converted to a Dalvik executable and runs your application.
Following is the default code generated by the application wizard for Hello
World! application −
package com.example.helloworld;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
Here, R.layout.activity_main refers to the activity_main.xml file located in
the res/layout folder. The onCreate() method is one of many methods that are figured
when an activity is loaded.

The Manifest File

Whatever component you develop as a part of your application, you must declare all its
components in a manifest.xml which resides at the root of the application project
directory. This file works as an interface between Android OS and your application, so if
you do not declare your component in this file, then it will not be considered by the OS.
For example, a default manifest file will look like as following file −
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.tutorialspoint7.myapplication">

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">

<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Here <application>...</application> tags enclosed the components related to the
application. Attribute android:icon will point to the application icon available
under res/drawable-hdpi. The application uses the image named ic_launcher.png
located in the drawable folders
The <activity> tag is used to specify an activity and android:name attribute specifies the
fully qualified class name of the Activity subclass and the android:label attributes
specifies a string to use as the label for the activity. You can specify multiple activities
using <activity> tags.
The action for the intent filter is named android.intent.action.MAIN to indicate that this
activity serves as the entry point for the application. The category for the intent-filter is
named android.intent.category.LAUNCHER to indicate that the application can be
launched from the device's launcher icon.
The @string refers to the strings.xml file explained below.
Hence, @string/app_name refers to the app_name string defined in the strings.xml file,
which is "HelloWorld". Similar way, other strings get populated in the application.
Following is the list of tags which you will use in your manifest file to specify different
Android application components −
 <activity>elements for activities
 <service> elements for services
 <receiver> elements for broadcast receivers
 <provider> elements for content providers
The Strings File
The strings.xml file is located in the res/values folder and it contains all the text that
your application uses. For example, the names of buttons, labels, default text, and
similar types of strings go into this file. This file is responsible for their textual content.
For example, a default strings file will look like as following file −
<resources>
<string name="app_name">HelloWorld</string>
<string name="hello_world">Hello world!</string>
<string name="menu_settings">Settings</string>
<string name="title_activity_main">MainActivity</string>
</resources>

The Layout File

The activity_main.xml is a layout file available in res/layout directory, that is referenced
by your application when building its interface. You will modify this file very frequently to
change the layout of your application. For your "Hello World!" application, this file will
have following content related to default layout −
<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" >

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:padding="@dimen/padding_medium"
android:text="@string/hello_world"
tools:context=".MainActivity" />

</RelativeLayout>
This is an example of simple RelativeLayout which we will study in a separate chapter.
The TextView is an Android control used to build the GUI and it have various attributes
like android:layout_width, android:layout_height etc which are being used to set its
width and height etc.. The @string refers to the strings.xml file located in the res/values
folder. Hence, @string/hello_world refers to the hello string defined in the strings.xml
file, which is "Hello World!".

Running the Application

Let's try to run our Hello World! application we just created. I assume you had created
your AVD while doing environment set-up. To run the app from Android studio, open
one of your project's activity files and click Run icon from the tool bar. Android studio
installs the app on your AVD and starts it and if everything is fine with your set-up and
application, it will display following Emulator window −

Congratulations!!! you have developed your first Android Application and now just keep
following rest of the tutorial step by step to become a great Android Developer. All the
very best.
There are many more items which you use to build a good Android application. Apart
from coding for the application, you take care of various other resources like static
content that your code uses, such as bitmaps, colors, layout definitions, user interface
strings, animation instructions, and more. These resources are always maintained
separately in various sub-directories under res/ directory of the project.
This tutorial will explain you how you can organize your application resources, specify
alternative resources and access them in your applications.

Organize resource in Android Studio

MyProject/
app/
manifest/
AndroidManifest.xml
java/
MyActivity.java
res/
drawable/
icon.png
layout/
activity_main.xml
info.xml
values/
strings.xml

Sr.No Directory & Resource Type

.

1
anim/
XML files that define property animations. They are saved in res/anim/ folder
and accessed from the R.anim class.

2
color/
XML files that define a state list of colors. They are saved in res/color/ and
accessed from the R.color class.

3
drawable/
Image files like .png, .jpg, .gif or XML files that are compiled into bitmaps, state
lists, shapes, animation drawable. They are saved in res/drawable/ and
accessed from the R.drawable class.

4
layout/
 XML files that define a user interface layout. They are saved in res/layout/ and
accessed from the R.layout class.

5
menu/
XML files that define application menus, such as an Options Menu, Context
Menu, or Sub Menu. They are saved in res/menu/ and accessed from
the R.menu class.

6
raw/
Arbitrary files to save in their raw form. You need to
call Resources.openRawResource() with the resource ID, which
is R.raw.filename to open such raw files.

7
values/
XML files that contain simple values, such as strings, integers, and colors. For
example, here are some filename conventions for resources you can create in
this directory −
 arrays.xml for resource arrays, and accessed from the R.array class.
 integers.xml for resource integers, and accessed from
the R.integer class.
 bools.xml for resource boolean, and accessed from the R.bool class.
 colors.xml for color values, and accessed from the R.color class.
 dimens.xml for dimension values, and accessed from the R.dimen class.
 strings.xml for string values, and accessed from the R.string class.
 styles.xml for styles, and accessed from the R.style class.

8
xml/
Arbitrary XML files that can be read at runtime by calling Resources.getXML().
You can save various configuration files here which will be used at run time.

Alternative Resources
Your application should provide alternative resources to support specific device
configurations. For example, you should include alternative drawable resources
( i.e.images ) for different screen resolution and alternative string resources for different
languages. At runtime, Android detects the current device configuration and loads the
appropriate resources for your application.
To specify configuration-specific alternatives for a set of resources, follow the following
steps −
  Create a new directory in res/ named in the form <resources_name>-
<config_qualifier>. Here resources_name will be any of the resources
mentioned in the above table, like layout, drawable etc. The qualifier will specify
an individual configuration for which these resources are to be used. You can
check official documentation for a complete list of qualifiers for different type of
resources.
 Save the respective alternative resources in this new directory. The resource files
must be named exactly the same as the default resource files as shown in the
below example, but these files will have content specific to the alternative. For
example though image file name will be same but for high resolution screen, its
resolution will be high.
Below is an example which specifies images for a default screen and alternative images
for high resolution screen.
MyProject/
app/
manifest/
AndroidManifest.xml
java/
MyActivity.java
res/
drawable/
icon.png
background.png
drawable-hdpi/
icon.png
background.png
layout/
activity_main.xml
info.xml
values/
strings.xml
Below is another example which specifies layout for a default language and alternative
layout for Arabic language.
MyProject/
app/
manifest/
AndroidManifest.xml
java/
MyActivity.java
res/
drawable/
icon.png
background.png
drawable-hdpi/
icon.png
 background.png
layout/
activity_main.xml
info.xml
layout-ar/
main.xml
values/
strings.xml
Accessing Resources
During your application development you will need to access defined resources either in
your code, or in your layout XML files. Following section explains how to access your
resources in both the scenarios −
Accessing Resources in Code
When your Android application is compiled, a R class gets generated, which contains
resource IDs for all the resources available in your res/ directory. You can use R class
to access that resource using sub-directory and resource name or directly resource ID.
Example
To access res/drawable/myimage.png and set an ImageView you will use following
code −
ImageView imageView = (ImageView) findViewById(R.id.myimageview);
imageView.setImageResource(R.drawable.myimage);
Here first line of the code make use of R.id.myimageview to get ImageView defined with
id myimageview in a Layout file. Second line of code makes use
of R.drawable.myimage to get an image with name myimage available in drawable sub-
directory under /res.
Example
Consider next example where res/values/strings.xml has following definition −
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="hello">Hello, World!</string>
</resources>
Now you can set the text on a TextView object with ID msg using a resource ID as
follows −
TextView msgTextView = (TextView) findViewById(R.id.msg);
msgTextView.setText(R.string.hello);
Example
Consider a layout res/layout/activity_main.xml with the following definition −
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >

<TextView android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, I am a TextView" />

<Button android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, I am a Button" />

</LinearLayout>
This application code will load this layout for an Activity, in the onCreate() method as
follows −
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
Accessing Resources in XML
Consider the following resource XML res/values/strings.xml file that includes a color
resource and a string resource −
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="opaque_red">#f00</color>
<string name="hello">Hello!</string>
</resources>
Now you can use these resources in the following layout file to set the text color and
text string as follows −
<?xml version="1.0" encoding="utf-8"?>
<EditText xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:textColor="@color/opaque_red"
android:text="@string/hello" />
Now if you will go through previous chapter once again where I have explained Hello
World! example, and I'm sure you will have better understanding on all the concepts
explained in this chapter. So I highly recommend to check previous chapter for working
example and check how I have used various resources at very basic level.