Android App / Project Folder Structure

To implement android apps, Android Studio is the official IDE (Integrated Development
Environment) which is freely provided by Google for android app development.

Once we setup android development environment using android studio and if we create a
sample application using android studio, our project folder structure will be like as shown
below. In case if you are not aware of creating an application using an android studio please
check this Android Hello World App.

The Android project structure on the disk might be differs from the above representation. To
see the actual file structure of the project, select Project from the Project dropdown instead of
Android.

The android app project will contain different types of app modules, source code files, and
resource files. We will explore all the folders and files in the android app.

Java Folder
This folder will contain all the java source code (.java) files which we’ll create during the
application development, including JUnit test code. Whenever we create any new
project/application, by default the class file MainActivity.java will create automatically under
the package name “com.tutlane.helloworld” like as shown below.
res (Resources) Folder
It’s an important folder that will contain all non-code resources, such as bitmap images, UI
strings, XML layouts like as shown below.

The res (Resources) will contain a different type of folders that are

Drawable Folder (res/drawable)

It will contain the different types of images as per the requirement of application. It’s a best
practice to add all the images in a drawable folder other than app/launcher icons for the
application development.

Layout Folder (res/layout)

This folder will contain all XML layout files which we used to define the user interface of our
application. Following is the structure of the layout folder in the android application.

Mipmap Folder (res/mipmap)

This folder will contain app / launcher icons that are used to show on the home screen. It will
contain different density type of icons such as hdpi, mdpi, xhdpi, xxhdpi, xxxhdpi, to use
different icons based on the size of the device.

Following is the structure of the mipmap folder in the android application.

Values Folder (res/values)

This folder will contain various XML files, such as strings, colors, style definitions and a static
array of strings or integers. Following is the structure of the values folder in android
application.
Manifests Folder
This folder will contain a manifest file (AndroidManifest.xml) for our android application.
This manifest file will contain information about our application such as android version,
access permissions, metadata, etc. of our application and its components. The manifest file will
act as an intermediate between android OS and our application.

Following is the structure of the manifests folder in the android application.

Gradle Scripts
In android, Gradle means automated build system and by using this we can define a build
configuration that applies to all modules in our application. In Gradle build.gradle (Project),
and build.gradle (Module) files are useful to build configurations that apply to all our app
modules or specific to one app module.
Following is the structure of Gradle Scripts in the android application.

Following are the important files which we need to implement an app in android studio.

Android Layout File (activity_main.xml)

The UI of our application will be designed in this file and it will contain Design and Text
modes. It will exists in the layouts folder and the structure of activity_main.xml file in Design
mode like as shown below.

We can make required design modifications in activity_main.xml file either using Design or
Text modes. If we switch to Text mode activity_main.xml file will contain a code like as
shown below.
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.tutlane.helloworld.MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</android.support.constraint.ConstraintLayout>

Android Main Activity File (MainActivity.java)

The main activity file in the android application is MainActivity.java and it will exist in
the java folder. The MainActivity.java file will contain the java code to handle all the
activities related to our app.

Following is the default code of MainActivity.java file which is generated by our HelloWorld
application.

package com.tutlane.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);
}
}

Android Manifest File (AndroidManifest.xml)

Generally, our application will contain multiple activities and we need to define all
those activities in the AndroidManifest.xml file. In our manifest file, we need to mention the
main activity for our app using the MAIN action and LAUNCHER category attributes in
intent filters (<intent-filter>). In case if we didn’t mention MAIN action or LAUNCHER
category for the main activity, our app icon will not appear in the home screen’s list of apps.
Following is the default code of AndroidManifest.xml file which is generated by our
HelloWorld application.

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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.tutlane.helloworld" >

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
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>

These are the main folders and files required to implement an application in android studio. If
you want to see the actual file structure of the project, select Project from the Project
dropdown instead of Android.
 Android Application Components
(Activities, Intents, Views, Layouts, Service)
In android, application components are the basic building blocks of an application and these
components will act as an entry point to allow system or user to access our app.

The following are the basic core application components that can be used in Android
application.

• Activities
• Intents
• Content Providers
• Broadcast Receivers
• Services

All these application components are defined in the android app description file
(AndroidMainfest.xml) like as shown below.

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

<manifest …..>
<application android:allowBackup="true" android:icon="@mipmap/ic_launcher" ……>
<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>

This is how we can define an android application components in AndroidManiFest.xml file.

Android Activities
In android, Activity represents a single screen with a user interface (UI) and it will acts an entry
point for the user’s to interact with app.

For example, a contacts app that is having multiple activities like showing a list of contacts,
add a new contact, and another activity to search for the contacts. All these activities in the
contact app are independent of each other but will work together to provide a better user
experience.
To know more about Activities in android check Android Activities.

Android Intents
In android, Intent is a messaging object which is used to request an action from another
component.

In android, intents are mainly used to perform the following things.

• Starting an Activity
• Starting a Service
• Delivering a Broadcast

There are two types of intents available in android, those are

1. Implicit Intents
2. Explicit Intents

To know more about Intents in android check this Android Intents.

Android Services
In android, Service is a component that keeps an app running in the background to perform
long-running operations based on our requirements. For Service, we don’t have any user
interface and it will run the apps in background like play music in background when the user
in different app.

We have two types of services available in android, those are

• Local Services
• Remote Services

To know more about Services in android check this Android Services.

Android Broadcast Receivers

In android, Broadcast Receiver is a component that will allow a system to deliver events to the
app like sending a low battery message to the app. The apps can also initiate broadcasts to let
other apps know that required data available in a device to use it.

Generally, we use Intents to deliver broadcast events to other apps and Broadcast Receivers
use status bar notifications to let the user know that broadcast event occurs.

To know more about Broadcast Receivers in android check this Android Broadcast Receivers.

Android Content Providers

In android, Content Providers are useful to exchange the data between the apps based on the
requests. The Content Providers can share the app data that stores in the file system, SQLite
database, on the web or any other storage location that our app can access.

By using Content Providers, other apps can query or modify the data of our app based on the
permissions provided by content provider. For example, android provides a Content Provider
(ContactsContract.Data) to manage contacts information, by using proper permissions any
app can query the content provider to perform read and write operations on contacts
information.

To know more about Content Providers in android check this Android Content Provider.

Additional Components
In android, we have additional components which are used to build the relationship between
the above components (Activities, Intents, Content Providers, Services and Broadcast
Receivers) to implement our application logic, those are

Component Description
Fragments These are used to represent the portion of user interface in an activity
Layouts These are used to define the user interface (UI) for an activity or app
These are used to build a user interface for an app using UI elements like buttons,
Views
lists, etc.
To build an android app we required external elements like images, audio files,
Resources
etc. other than coding
It’s a configuration file (AndroidManifest.xml) for the application and it will
Manifest
contain the information about Activities, Intents, Content Providers, Services,
File
Broadcast Receivers, permissions, etc.

These are the main application components which are required to build an android application
based on our requirements.
 Android Activity Lifecycle
In android, Activity represents a single screen with a user interface (UI) of an application and
it will acts an entry point for users to interact with an app.

Generally, the android apps will contain multiple screens and each screen of our application
will be an extension of Activity class. By using activities, we can place all our android
application UI components in a single screen.

From the multiple activities in android app, one activity can be marked as a main activity and
that is the first screen to appear when we launch the application. In android app each activity
can start another activity to perform different actions based on our requirements.

For example, a contacts app which is having multiple activities, in that the main activity screen
will show a list of contacts and from the main activity screen we can launch other activities
that provide screens to perform tasks like add a new contact and search for the contacts. All
these activities in the contact app are loosely bound to other activities but will work together
to provide a better user experience.

Generally, in android there is a minimal dependency between the activities in an app. To use
activities in application we need to register those activities information in our app’s manifest
file (AndroidMainfest.xml) and need to manage activity life cycle properly.

To use activities in our application we need to define an activities with required attributes in
manifest file (AndroidMainfest.xml) like as shown below

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

<manifest …..>
<application …..>
<activity android:name=".MainActivity" >
…….

…….

</activity>

…….

</application>
</manifest>

The activity attribute android:name will represent the name of class and we can also add
multiple attributes like icon, label, theme, permissions, etc. to an activity element based on our
requirements.
In android application, activities can be implemented as a subclass of Activity class like as
shown below.

public class MainActivity extends Activity {

This is how we can activities in android application based on our requirements.

Android Activity Lifecycle

Generally, the activities in our android application will go through a different stages in their
life cycle. In android, Activity class have 7 callback methods like onCreate(), onStart(),
onPause(), onRestart(), onResume(), onStop() and onDestroy() to describe how the
activity will behave at different stages.

By using activity cal-back methods we can define how our activity can behave when the user
enter or leaves our application.

Android Activity Lifecycle Callback Methods

In android, an activity goes through a series of states during its lifetime. By using callback
methods we can get the activity transitions between the states.

Android system initiates its program within an Activity starting with a call on onCreate()
callback method. There is a sequence of callback methods that start up an activity and a
sequence of callback methods that tear down an activity.

This section will give you detailed information about callback methods to handle activity
transitions between states during the lifecycle.

onCreate()
This is the first callback method and it fires when the system creates an activity for the first
time. During the activity creation, activity entered into a Created state.

If we have an application start-up logic that needs to perform only once during the life cycle of
an activity, then we can write that logic in onCreate() method.

Following is the example of defining a onCreate() method in android activity.

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
Once onCreate() method execution is finished, the activity will enter into Started state and
the system calls the onStart() method.

onStart()
The onStart() callback method will invoke when an activity entered into Started State by
completing onCreate() method. The onStart() method will make an activity visible to the
user and this method execution will finish very quickly.

Following is the example of defining a onStart() method in android activity.

@Override
protected void onStart()
{
super.onStart()
}

After completion of onStart() method execution, the activity enters into Resumed state and
system invoke the onResume() method.

onResume()
When an activity entered into Resumed state, the system invokes onResume() call back
method. In this state activity start interacting with the user that means user can see the
functionality and designing part of an application on the single screen.

Mostly the core functionality of an app is implemented in onResume() method.

The app will stay in this Resumed state until an another activity happens to take focus away
from the app like getting a phone call or screen turned off, etc.

In case if any interruption events happen in Resumed state, the activity will enter into Paused
state and the system will invoke onPause() method.

After an activity returned from Paused state to Resumed state, the system again will call
onResume() method due to this we need to implement onResume() method to initialize the
components that we release during onPause() method

Following is the example of defining a onResume() method in android activity.

@Override
public void onResume() {
super.onResume();
if (mCamera == null) {
initializeCamera();
}
}
If any interruption happens in Resumed state, the activity will enter into Paused state and the
system will invoke onPause() method.

onPause()
Whenever the user leaves an activity or the current activity is being Paused then the system
invokes onPause() method. The onPause() method is used to pause operations like stop
playing the music when the activity is in a paused state or pass an activity while switching from
one app to another app because every time only one app can be focused.

Following is the example of defining a onPause() method in android activity.

@Override
public void onPause() {
super.onPause();
if (mCamera != null) {
mCamera.release();
mCamera = null;
}
}

After completion of onPause() method execution, the next method is either onStop() or
onResume() depending on what happens after an activity entered into a Paused state.

onStop()
The system will invoke onStop() callback method when an activity no longer visible to the
user, the activity will enter into Stopped state. This happens due to current activity entered into
Resumed state or newly launched activity covers complete screen or it’s been destroyed.

The onStop() method is useful to release all the app resources which are no longer needed to
the user.

Following is the example of defining a onStop() method in android activity.

@Override
protected void onStop()
{
super.onStop();
}

The next callback method which raised by the system is either onRestart(), in case if the
activity coming back to interact with the user or onDestroy(), in case if the activity finished
running.

onRestart()
The system will invoke onRestart() method when an activity restarting itself after stopping
it. The onRestart() method will restore the state of activity from the time that is being
stopped.

The onRestart() callback method in android activity will always be followed by onStart()
method.

onDestroy()
The system will invoke onDestroy() method before an activity is destroyed and this is the
final callback method received by the android activity.

The system will invoke this onDestory() callback method either the activity is finishing or
system destroying the activity to save space.

Following is the example of defining a onDestroy() method in android activity.

@Override
public void onDestroy()
{
super.onDestroy();
}

The onDestroy() method will release all the resources which are not released by previous
callback onStop() method.

Android Activity Lifecycle Diagram

Generally, in android activity class uses different callback methods like onCreate(),
onStart(), onPause(), onRestart(), onResume(), onStop() and onDestroy() to go
through a different stages of activity life cycle.

Following is the pictorial representation of the Android Activity Life cycle which shows how
Activity will behave in different stages using callback methods.
Whenever the user trying to leave an activity like switching from one app to another app, the
system will use callback methods to dismantle the activity completely or partially to resume
the activity from where the user left off.

Based on our requirements we can implement the activity in the android app using the callback
method and it’s not necessary to use all callback methods in each android application.

Android Activity Lifecycle Example

Now we will see, how the android activity lifecycle will work with an example. Following is
the example of invoking activity callback methods to see the life cycle process of activity in
android application.
Here we are going to use previously created Android Hello World App example and making
some modifications to MainActivity.java file like as shown below to capture Android Activity
Life Cycle process.

MainActivity.java File Code

The following are the code modifications which made to include all life cycle callback methods
in MainActivity.java file which is in \java\com.tutlane.helloworld directory.

package com.tutlane.helloworld;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d("Activity Lifecycle","onCreate invoked");
}
@Override
protected void onStart() {
super.onStart();
Log.d("Activity Lifecycle","onStart invoked");
}
@Override
protected void onResume() {
super.onResume();
Log.d("Activity Lifecycle","onResume invoked");
}
@Override
protected void onPause() {
super.onPause();
Log.d("Activity Lifecycle","onPause invoked");
}
@Override
protected void onStop() {
super.onStop();
Log.d("Activity Lifecycle","onStop invoked");
}
@Override
protected void onRestart() {
super.onRestart();
Log.d("Activity Lifecycle","onRestart invoked");
}
@Override
 protected void onDestroy() {
super.onDestroy();
Log.d("Activity Lifecycle","onDestroy invoked");
}
}

If you observe above code we defined a statement like

“setContentView(R.layout.activity_main);” which will help to load all UI components defined
in activity_main.xml file and used Log.d() method to generate log messages.

In our application we can have more than one activity file and we need to declare all the
activities in the AndroidManifest.xml file. In the manifest XML file, by using MAIN action
and LAUNCHER category attributes in intent filters (<intent-filter>) we can mention the
main activity that opens when the user initially launches our app with the launcher icon. In case
if we didn’t mention the MAIN action, then the system will decide which activity needs to start
and if we didn’t add the LAUNCHER category for the main activity, our app icon will not
appear in the home screen’s list of apps.

The code of AndroidManifest.xml file will be like as shown below.

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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.tutlane.helloworld" >

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
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>

Output of Android Activity Lifecycle Example

Now run your application using Android Virtual Device (AVD) in android studio by clicking
on Play icon in toolbar or press Shift + F10. Our application result will be like as shown
below.
 Now open Android Device Monitor (Tools à Android à Android Device Monitor) to see our
log messages in the LogCat window in android studio like as shown below.

If you observe log messages in LogCat window onCreate, onStart and onResume methods
are invoked by system.

Now click on Home button in Android Emulator, immediately activity entered into Paused
state and system will invoke onPause() method like as shown below.
After a while, the activity will enter into Stopped state and system will invoke onStop()
method like as shown below.

Now again launch our app from the Home screen list of apps like as shown below.
If you observe log messages in the LogCat window again onRestart, onStart and onResume
methods are invoked by system like as shown below.

Now click on Back button in the android emulator, the system will invoke the onPause method
and after a while onStop, onDestroy methods will be invoked like as shown below.

Here we need to remember that onCreate and onDestroy methods will invoke only once
throughout the activity life cycle.

This is how android activity life cycle process will invoke different methods while transition
from one stage to another stage.