Difference between build.gradle (Project) and build.gradle (Module)

It's a bit confusing because Android Studio by default shows both build.gradle files right next to each other (when using the Android view).

If you switch to the Project view you can see the actual structure and where the different build.gradle files are located.

The build.gradle (Project: MyApplication) file is in the root folder of the project and its configuration settings apply to every module in the project. A module is an isolated piece of the bigger project. In a multi-module project, these modules have their own jobs but work together to form the whole project. Most Android projects only have one module, the app module.

The build.gradle (Module: app) file here is in the app folder. Its build settings apply only to the app module. If there were another module, then that module would have its own build.gradle file, too. As an example, I made a library project with three modules: a library module, a demo app module, and another app module that I plan to use for testing. Each of them have their own build.gradle files that I can tweak.

In a basic project, almost everything you need to edit will be in the app module's build.gradle file. You can remember it like this:

You're making an app, so go to the build.gradle (Module: app) file.

Further reading

• Configure Your Build (Android documentation--very readable and useful)
• Introduction to multi-project builds (Gradle documentation)

build.gradle (Project:My-app)

Top-level build file where you can add configuration options common to all sub-projects/modules.

Each project contains a top-level Gradle file. It usually contains common configurations for all modules. Whatever is included in this top-level Gradle gile, it will affect all modules.

Example:

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.0.0-alpha3'

        //Maven plugin
        classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        jcenter()
        maven { url "https://jitpack.io" }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

build.gradle (Module:app)

Build file of your specific module (where you add your dependencies, signing configurations, build types, flavors, etc.)

All modules have a specific Gradle file. Whatever is included in this gradle file, it will only affect the module that is included on.

Example:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.2"

    defaultConfig {
        applicationId "com.hrskrs.gesturefun"
        minSdkVersion 10
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            zipAlignEnabled true
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        debug {
            debuggable true
            zipAlignEnabled true
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile project(':gesture-fun')
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.1.1'
    compile 'com.android.support:design:23.1.1'
    compile 'com.jakewharton:butterknife:7.0.1'
}

About the relation of the two gradle files, hrskrs made a very clear explanation，and I will make some supplement about it.

If your project only has one Module (such as app), the advantage of the top build.gradle (Project:My-app) not show very clear. Because you can configure everything in build.gradle (Module:app) about the Module, and only modify one file when upgrading in the following days.

But if your project has five modules, and it happened that they have a same dependence A, if you don’t use the top build.gradle (Project: My-app) you need to maintain five files in the following days.

By the way, the build.gradle (Module:app) can overwrite the build.gradle (Project:My-app).

This design can improve the maintainability of the app.

[Project vs Module]

Projects' build.gradle file is used for common/shared logic. For example, you can define repositories here (Maven, Google, JCenter, and custom) or specify ext {} with shared variables or classpath^[About].

Module's build.gradle is used for the current module, like dependencies, minSdkVersion, targetSdkVersion, compileSdkVersion^[About], ProGuard settings^[About]. Usually as a developer you should take care of this file.