Estou tentando adicionar uma dependência do Android Asynchronous Http Client em meu projeto. Portanto, há dois arquivos build.gradle no projeto.

Pelo meu entendimento, existem diferentes tipos de dependências:

1. Um que foi definido no nível raiz de build.gradle (Projeto: My-app)
2. Um dentro do buildscript do build.gradle (Project: My-app)
3. Outro é build.gradle (Módulos: app)

Esta questão é sobre repositórios para dependências do buildScript, explique um pouco sobre os primeiros dois tipos.

Também build.gradle (Project: My-app) diz

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

Portanto, acho que o código de dependência do cliente Http Android Asynchronous deve ser adicionado em build.gradle (Módulo: app).

Se alguém pudesse dar uma imagem clara de tudo isso para melhor compreensão, seria ótimo.

build.gradle(Project:My-app)

Arquivo de construção de nível superior onde você pode adicionar opções de configuração comuns a todos os subprojetos / módulos.

Cada projeto contém umtop-level gradle file . Geralmente contém common configspara todos modules. O que quer que esteja incluído nisso top-level gradle, afetará a todos 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)

Arquivo de compilação de seu módulo específico (onde você adiciona suas dependências, assinando configurações, tipos de compilação, sabores, etc)

Todos modulespossuem um gradlearquivo específico . O que quer que esteja incluído neste gradlearquivo, afetará apenas o moduleque está incluído no.

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

É um pouco confuso porque o Android Studio, por padrão, mostra os dois build.gradlearquivos um ao lado do outro (ao usar a visualização do Android).

Se você mudar para a visualização Projeto, poderá ver a estrutura real e onde os diferentes build.gradlearquivos estão localizados.

O build.gradlearquivo (Projeto: MyApplication) está na pasta raiz do projeto e suas definições de configuração se aplicam a todos os módulos do projeto. Um módulo é uma parte isolada do projeto maior. Em um projeto com vários módulos, esses módulos têm suas próprias tarefas, mas trabalham juntos para formar o projeto inteiro. A maioria dos projetos Android tem apenas um módulo, o módulo de app.

O build.gradlearquivo (Módulo: app) aqui está na apppasta. Suas configurações de compilação se aplicam apenas ao módulo de app. Se houvesse outro módulo, esse módulo também teria seu próprio build.gradlearquivo. Como exemplo , fiz um projeto de biblioteca com três módulos: um módulo de biblioteca, um módulo de aplicativo de demonstração e outro módulo de aplicativo que pretendo usar para teste. Cada um deles tem seus próprios build.gradlearquivos que posso ajustar.

Em um projeto básico, quase tudo que você precisa editar estará no build.gradlearquivo do módulo do app . Você pode se lembrar assim:

Você está criando um aplicativo , então vá para o arquivo build.gradle(Módulo: aplicativo ).

Leitura adicional

• Configure sua compilação (documentação do Android - muito legível e útil)
• Introdução às compilações de vários projetos (documentação do Gradle)

Sobre a relação dos dois gradlearquivos, hrskrs deu uma explicação muito clara, farei algum suplemento sobre isso.

se o seu projeto tiver apenas um módulo (como app ), a vantagem do top build.gradle (Project: My-app) não é muito clara. porque você pode configurar tudo em build.gradle (Módulo: app) sobre o Módulo e apenas modificar um arquivo ao atualizar nos dias seguintes。

mas se seu projeto tem 5 módulos, e acontece que eles têm a mesma dependência A , se você não usa o build.gradle superior (Projeto: My-app) você precisa manter 5 arquivos nos dias seguintes.

a propósito, o build.gradle (Módulo: app) pode sobrescrever o build.gradle (Projeto: My-app) .

Este projeto pode melhorar a manutenção do APP