The following is the first few sections of a chapter from The Busy Coder's Guide to Android Development, plus headings for the remaining major sections, to give you an idea about the content of the chapter.

Contents of Android Projects

The Android build system is organized around a specific directory tree structure for your Android project, much like any other Java project. The specifics, though, are fairly unique to Android — the Android build tools do a few extra things to prepare the actual application that will run on the device or emulator.

Here is a quick primer on the project structure, to help you make sense of it all, particularly for the sample code referenced in this book.

What You Get, In General

The details of exactly what files are in your project depend on a variety of things:

However, usually, there are many elements in common.

The Modules

A default Android Studio project will have an app/ directory off of the project root directory (i.e., the directory in which you told Android Studio to create the project). That app/ directory represents what Android Studio refers to as a module. Most projects just have this one app/ module, though you can have more than one module if needed.

The Source Sets

Inside of app/ you will find a src/main/ directory. This represents the main source set, and it contains all of the “source” that your project is contributing to build the application. Here, “source” means more than just programming language source code (e.g., Java). It also includes other types of files, such as resources and the manifest, that contribute to the app.

The Manifest

Inside of app/src/main/, you will find a file named AndroidManifest.xml. AndroidManifest.xml is an XML file describing the application being built and what components — activities, services, etc. — are being supplied by that application. You can think of it as being the “table of contents” of what your application is about, much as a book has a “table of contents” listing the various parts, chapters, and appendices that appear in the book.

We will examine the manifest a bit more closely starting in the next chapter.

The Java

When you created the project, if you had Android Studio create an activity for you, you supplied the class name of the “main” activity for the application (e.g., MainActivity). That will be combined with the package name that you provided for the project to determine the fully-qualified class name for this activity (e.g.,

You will find that your project’s Java source tree already has the package’s directory tree in place, plus a class representing your requested activity (e.g., com/commonsware/android/ This will be inside the main source set, so the full path from the project root would be something like app/src/main/java/com/commonsware/android/

You are welcome to modify this file and add Java classes as needed to implement your application, and we will demonstrate that countless times as we progress through this book.

Elsewhere — in directories that you normally do not work with — the Android build tools will also be code-generating some source code for you each time you build your app. One of the code-generated Java classes ( will be important for controlling our user interfaces from our own Java code, and we will see many references to this R class as we start building applications in earnest.

The Resources

You will also find that your project has a res/ directory tree inside of the main source set. This holds “resources” — static files that are packaged along with your application, either in their original form or, occasionally, in a preprocessed form. Some of the subdirectories you will find or create under res/ include:

  1. res/drawable/ and res/mipmap-*/ (for a few values of *) for images (PNG, JPEG, etc.)
  2. res/layout/ for XML-based UI layout specifications
  3. res/menu/ for XML-based menu specifications
  4. res/raw/ for general-purpose files (e.g., an audio clip, a CSV file of account information)
  5. res/values/ for strings, dimensions, and the like
  6. res/xml/ for other general-purpose XML files you wish to ship

Some of the directory names may have suffixes, like res/mipmap-hdpi/. This indicates that the directory of resources should only be used in certain circumstances — in this case, the mipmap resources are designed for devices with high-density screens.

We will cover all of these, and more, later in this book.

The Build Instructions

The IDE needs to know how to take all of this stuff and come up with an Android APK file. Some of this is already “known” to the IDE based upon how the IDE was written. But some details are things that you may need to configure from time to time, and so those details are stored in files that you will edit, by one means or another, from your IDE.

In Android Studio, most of this knowledge is kept in files named build.gradle. These are for a build engine known as Gradle, that Android Studio uses to build APKs and other Android outputs.

More About the Directory Structure

The preview of this section was the victim of a MITM ('Martian in the middle') attack.

What You Get Out Of It

The preview of this section is in the process of being translated from its native Klingon.