J'essaye d'ajouter une dépendance d'Android Asynchronous Http Client dans mon projet. Il y a donc deux fichiers build.gradle dans le projet.

Selon ce que je comprends, il existe différents types de dépendances:

1. Celui qui a défini au niveau racine de build.gradle (Projet: My-app)
2. Un dans le buildscript de build.gradle (Projet: My-app)
3. Un autre est build.gradle (Modules: app)

Cette question concerne les référentiels pour les dépendances du buildScript, expliquez un peu les deux premiers types.

Build.gradle (Project: My-app) dit également

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

Je suppose donc que le code de dépendance d'Android Asynchronous Http Client devrait être ajouté dans build.gradle (Module: app).

Si quelqu'un pouvait donner une image claire de tout cela pour une meilleure compréhension, ce serait formidable.

build.gradle(Project:My-app)

Fichier de construction de niveau supérieur dans lequel vous pouvez ajouter des options de configuration communes à tous les sous-projets / modules.

Chaque projet contient un fichiertop-level gradle file . Il contient généralement common configspour tous modules. Quoi qu'il en soit top-level gradle, cela affectera tout le monde modules.

ex:

// 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)

Fichier de construction de votre module spécifique (dans lequel vous ajoutez vos dépendances, signalez les configurations, les types de construction, les saveurs, etc.)

Tous modulesont un gradlefichier spécifique . Tout ce qui est inclus dans ce gradlefichier, cela n'affectera moduleque le qui est inclus sur.

ex:

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'
}

C'est un peu déroutant car Android Studio affiche par défaut les deux build.gradlefichiers l'un à côté de l'autre (lors de l'utilisation de la vue Android).

Si vous passez à la vue Projet, vous pouvez voir la structure réelle et l'emplacement des différents build.gradlefichiers.

Le build.gradlefichier (Project: MyApplication) se trouve dans le dossier racine du projet et ses paramètres de configuration s'appliquent à chaque module du projet. Un module est un élément isolé du plus grand projet. Dans un projet multi-modules, ces modules ont leurs propres tâches mais fonctionnent ensemble pour former l'ensemble du projet. La plupart des projets Android n'ont qu'un seul module, le module d'application.

Le build.gradlefichier (Module: app) se trouve ici dans le appdossier. Ses paramètres de construction s'appliquent uniquement au module d'application. S'il y avait un autre module, ce module aurait aussi son propre build.gradlefichier. À titre d' exemple , j'ai créé un projet de bibliothèque avec trois modules: un module de bibliothèque, un module d'application de démonstration et un autre module d'application que je prévois d'utiliser pour les tests. Chacun d'eux a ses propres build.gradlefichiers que je peux modifier.

Dans un projet de base, presque tout ce que vous devez modifier sera dans le build.gradlefichier du module d'application . Vous pouvez vous en souvenir comme ceci:

Vous créez une application , alors accédez au fichier build.gradle(Module: app ).

Lectures complémentaires

• Configurez votre build (documentation Android - très lisible et utile)
• Introduction aux builds multi-projets (documentation Gradle)

À propos de la relation des deux gradlefichiers, hrskrs a donné une explication très claire ， Je vais faire un supplément à ce sujet.

si votre projet n'a qu'un seul module (comme app ), l'avantage de top build.gradle (Project: My-app) n'est pas très clair. car vous pouvez tout configurer dans build.gradle (Module: app) sur le module, et ne modifier qu'un seul fichier lors de la mise à niveau dans les jours suivants。

mais si votre projet a 5 modules, et qu'il se trouve qu'ils ont la même dépendance A , si vous n'utilisez pas le top build.gradle (Project: My-app), vous devez maintenir 5 fichiers les jours suivants.

en passant, le build.gradle (Module: app) peut écraser le build.gradle (Project: My-app) .

Cette conception peut améliorer la maintenabilité de l'APP