Hello World App

Creating your first App

App Directory Structure
Manifest File
Layout Resource
Android Virtual Device (Emulator)
Running your App on Emulator
How to make android apps
In this page, you will know how to create the
simple hello android application. We are creating
the simple example of android using the Eclipse
IDE.

For creating the simple example:

1.Create the new android project
2.Write the message (optional)
3.Run the android application

Hello Android Example

You need to follow the 3 steps mentioned above
for creating the Hello android application.
1) Create the New Android project
For creating the new android project:
1) Select File > New > Project...
2) Select the android project and click next
3) Fill the Details in this dialog box and click finish
Now an android project have been created. You
can explore the android project and see the simple
program, it looks like this:
2) Write the message
For writing the message we are using the TextView
class. Change the onCreate method as:

1.TextView textview=new TextView(this);

2.textview.setText("Hello Android!");
3.setContentView(textview);
Let's see the full code of MainActivity.java file.

1.package com.example.helloandroid;
2.import android.os.Bundle;
3.import android.app.Activity;
4.import android.view.Menu;
5.import android.widget.TextView;
6.public class MainActivity extends Activity {
7. @Override
8. protected void onCreate(Bundle savedInstanceState) {
9. super.onCreate(savedInstanceState);
10. TextView textview=new TextView(this);
11. textview.setText("Hello Android!");
12. setContentView(textview);
13. }
14. @Override
15. public boolean onCreateOptionsMenu(Menu menu) {
16. // Inflate the menu; this adds items to the action bar if it is present.
17. getMenuInflater().inflate(R.menu.activity_main, menu);
18. return true;
19. }
20.}
To understand the first android application directory structure we will discuss the
internal details of hello android example elaborately.
3) Run the android application
To run the android application:
Right click on your project > Run As.. > Android Application
The android emulator might take 2 or 3 minutes to boot. So please have patience. After
booting the emulator, the eclipse plugin installs the application and launches the activity. You
will see something like this:
 Internal Details of Hello Android Example
Here, we are going to learn the internal details or working of hello android example.

Android application contains different components such as java source code, string
resources, images, manifest file, apk file etc. Let's understand the project structure of
android application.
Java Source Code
Let's see the java source file created by the Eclipse IDE and/or Android Studio:
File: MainActivity.java

1.package com.example.helloandroid;
2.import android.os.Bundle;
3.import android.app.Activity;
4.import android.view.Menu;
5.import android.widget.TextView;
6.public class MainActivity extends Activity {//(1)
7. @Override
8. protected void onCreate(Bundle savedInstanceState) {//(2)
9. super.onCreate(savedInstanceState);
10.
11. setContentView(R.layout.activity_main);//(3)
12. }
13. @Override
14. public boolean onCreateOptionsMenu(Menu menu) {//(4)
15. // Inflate the menu; this adds items to the action bar if it is present.
16. getMenuInflater().inflate(R.menu.activity_main, menu);
17. return true;
18. }
19.}
(1) Activity is a java class that creates and default window on the screen where
we can place different components such as Button, EditText, TextView, Spinner etc.
It is like the Frame of Java AWT.

It provides life cycle methods for activity such as onCreate, onStop, OnResume etc.

(2) The onCreate method is called when Activity class is first created.

(3) The setContentView(R.layout.activity_main) gives information about our

layout resource. Here, our layout resources are defined in activity_main.xml file.
File: activity_main.xml

1.<RelativeLayout xmlns:androclass="http://schemas.android.com/apk/res/android"
2. xmlns:tools="http://schemas.android.com/tools"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. tools:context=".MainActivity" >
6. <TextView
7. android:layout_width="wrap_content"
8. android:layout_height="wrap_content"
9. android:layout_centerHorizontal="true"
10. android:layout_centerVertical="true"
11. android:text="@string/hello_world" />
12.</RelativeLayout>
As you can see, a textview is created by the framework automatically. But the message
for this string is defined in the strings.xml file. The @string/hello_world provides
information about the textview message. The value of the attribute hello_world is defined
in the strings.xml file.

File: strings.xml

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

2.<resources>
3. <string name="app_name">helloandroid</string>
4. <string name="hello_world">Hello world!</string>
5. <string name="menu_settings">Settings</string>
6.</resources>

You can change the value of the hello_world attribute from this file.
Generated R.java file
It is the auto-generated file that contains IDs for all the resources of res directory. It is
generated by aapt(Android Asset Packaging Tool). Whenever you create any component on
activity_main, a corresponding ID is created in the R.java file which can be used in the Java
Source file later.
File: R.java
1./* AUTO-GENERATED FILE. DO NOT MODIFY.
2. *
3. * This class was automatically generated by the
4. * aapt tool from the resource data it found. It
5. * should not be modified by hand.
6. */
7.package com.example.helloandroid;
8.public final class R {
9. public static final class attr {
10. }
11. public static final class drawable {
12. public static final int ic_launcher=0x7f020000;
13. }
14. public static final class id {
15. public static final int menu_settings=0x7f070000;
16. }
17. public static final class layout {
18. public static final int activity_main=0x7f030000;} ..continue
Continue.

public static final class menu {

public static final int activity_main=0x7f060000; }
public static final class string {
public static final int app_name=0x7f040000;
public static final int hello_world=0x7f040001;
public static final int menu_settings=0x7f040002;
}
public static final class style {
public static final int AppBaseTheme=0x7f050000;
/** Application theme. All customizations that are NOT specific to a particular API-
level can go here.
*/
public static final int AppTheme=0x7f050001;
}
}
APK File
An apk file is created by the framework automatically. If you want to run the
android application on the mobile, transfer and install it.

Resources
It contains resource files including activity_main, strings, styles etc.

Manifest file
It contains information about package including components such as activities,
services, content providers etc.
AndroidManifest.xml file in android

The AndroidManifest.xml file contains information of your package, including components

of the application such as activities, services, broadcast receivers, content providers etc.

It performs some other tasks also:

It is responsible to protect the application to access any protected parts by providing
the permissions.
It also declares the android api that the application is going to use.
It lists the instrumentation classes. The instrumentation classes provides profiling and
other informations. These informations are removed just before the application is published
etc.

This is the required xml file for all the android application and located inside the root
directory.
A simple AndroidManifest.xml file looks like this:

1.<manifest xmlns:android="http://schemas.android.com/apk/res/android"
2. package="com.javatpoint.hello"
3. android:versionCode="1"
4. android:versionName="1.0" >
5. <uses-sdk
6. android:minSdkVersion="8"
7. android:targetSdkVersion="15" />
8. <application
9. android:icon="@drawable/ic_launcher"
10. android:label="@string/app_name"
11. android:theme="@style/AppTheme" >
12. <activity
13. android:name=".MainActivity"
14. android:label="@string/title_activity_main" >
15. <intent-filter>
16. <action android:name="android.intent.action.MAIN" />
17. <category android:name="android.intent.category.LAUNCHER" />
18. </intent-filter>
19. </activity>
20. </application>
21.</manifest>
Elements of the AndroidManifest.xml file

The elements used in the above xml file are described below.

<manifest>
manifest is the root element of the AndroidManifest.xml file. It has package attribute that
describes the package name of the activity class.

<application>
application is the subelement of the manifest. It includes the namespace declaration. This
element contains several subelements that declares the application component such as activity
etc.

The commonly used attributes are of this element are icon, label, theme etc.
android:icon represents the icon for all the android application components.
android:label works as the default label for all the application components.
android:theme represents a common theme for all the android activities.

<activity>
activity is the subelement of application and represents an activity that must be defined in
the AndroidManifest.xml file. It has many attributes such as label, name, theme, launchMode
etc.
android:label represents a label i.e. displayed on the screen.
android:name represents a name for the activity class. It is required attribute.
<intent-filter>

intent-filter is the sub-element of activity that describes the type of intent to

which activity, service or broadcast receiver can respond to.

<action>
It adds an action for the intent-filter. The intent-filter must have at least one
action element.

<category>
It adds a category name to an intent-filter.
Android R.java file

Android R.java is an auto-generated file by aapt (Android Asset Packaging Tool) that contains
resource IDs for all the resources of res/ directory.

If you create any component in the activity_main.xml file, id for the corresponding component is
automatically created in this file. This id can be used in the activity source file to perform any
action on the component.

Note: If you delete R.jar file, android creates it

automatically.
Dalvik Virtual Machine | DVM

As we know the modern JVM is high performance and provides excellent memory
management. But it needs to be optimized for low-powered handheld devices as well.

The Dalvik Virtual Machine (DVM) is an android virtual machine optimized for mobile
devices. It optimizes the virtual machine for memory, battery life and performance.
Dalvik is a name of a town in Iceland. The Dalvik VM was written by Dan Bornstein.
The Dex compiler converts the class files into the .dex file that run on the Dalvik VM.
Multiple class files are converted into one dex file.
 Let's see the compiling and packaging process from the source file:

The javac tool compiles the java source file into the class file.
The dx tool takes all the class files of your application and generates a single .dex file. It is a
platform-specific tool.
The Android Assets Packaging Tool (aapt) handles the packaging process.