Skip to content

Most visited

Recently visited

navigation

Configure sua compilação

Vídeo

O novo sistema de compilação do SDK do Android

O sistema de compilação do Android compila os recursos e o código-fonte do aplicativo e os empacote em APKs que você pode testar, implantar, assinar e distribuir. O Android Studio usa o Gradle, um kit de ferramentas de compilação avançado, para automatizar e gerenciar o processo de compilação, permitindo que você defina configurações de compilação personalizadas e flexíveis. Cada configuração de compilação pode definir seu próprio conjunto de códigos e recursos, reutilizando as partes comuns a todas as versões do aplicativo. O Android Plugin for Gradle funciona com o kit de ferramentas de compilação para fornecer processos e configurações ajustáveis que são específicas para compilar e testar aplicativos Android.

O Gradle e o plug-in do Android são executados de forma independente do Studio. Isso significa que você pode compilar seus aplicativos Android pelo Android Studio, pela linha de comando do seu computador ou em computadores nos quais o Android Studio não esteja instalado (como servidores de integração contínua). Se você não estiver usando o Android Studio, veja como compilar e executar seu aplicativo pela linha de comando. A saída da compilação é a mesma, esteja você compilando o projeto em uma linha de comando, em um computador remoto ou usando o Android Studio.

Observação: como o Gradle e o plug-in do Android são executado de forma independente do Android Studio, você precisa atualizar as ferramentas de compilação separadamente. Leia as notas da versão para saber como atualizar o Gradle e o plug-in do Android.

A flexibilidade do sistema de compilação do Android permite realizar configurações de compilação personalizadas sem modificar os arquivos dos recursos principais do aplicativo. Esta seção ajuda a entender como o sistema de compilação do Android funciona e como ele pode ajudar a personalizar e automatizar várias configurações de compilação. Se quiser saber mais saber como implantar seu aplicativo, consulte Como programar e executar no Android Studio. Para começar a criar configurações de compilação personalizadas imediatamente usando o Android Studio, consulte Como configurar variantes de compilação.

O processo de compilação

O processo de compilação envolve muitas ferramentas e processos que convertem seu projeto em um pacote de aplicativo Android (APK). Como esse processo é bem flexível, é útil entender como ele funciona.

Figura 1. O processo de compilação de um módulo de aplicativo Android típico.

O processo de compilação de um módulo de aplicativo Android típico, conforme é mostrado na figura 1, segue as seguintes etapas gerais:

  1. Os compiladores convertem seu código-fonte em arquivos DEX (Dalvik Executable), que incluem o bytecode que é executado em dispositivos Android e todo o restante em recursos compilados.
  2. O APK Packager combina os arquivos DEX e os recursos compilados em um só APK. No entanto, para que seu aplicativo possa ser instalado e implantado em um dispositivo Android, o APK deve ser assinado.
  3. O APK Packager assina o APK usando o repositório de chaves de lançamento ou de depuração:
    1. Se você estiver compilando uma versão de depuração do seu aplicativo, ou seja, um aplicativo apenas para teste e geração de perfis, o Packager o assina com o repositório de chaves de depuração. O Android Studio automaticamente configura novos projetos com um repositório de chaves de depuração.
    2. Se você estiver compilando uma versão de lançamento do seu aplicativo que pretende lançar externamente, o Packager o assina usando o repositório de chaves de lançamento. Para criar um repositório de chaves de lançamento, leia sobre como assinar seu aplicativo no Android Studio.
  4. Antes de gerar seu APK final, o Packager usa a ferramenta zipalign para otimizar seu aplicativo para usar menos memória quando ele for executado em um dispositivo.

No final do processo de compilação, você tem um APK de depuração ou de lançamento do seu aplicativo que pode ser usando para implantar, testar ou lançar o aplicativo para usuários externos.

Configurações de compilação personalizadas

O Gradle e o plug-in do Android ajudam você a configurar os seguintes aspectos da sua compilação:

Tipos de compilação
Os tipos de compilação definem certas propriedades que o Gradle usa ao compilar e empacotar seu aplicativo e, geralmente, eles são configurados para diferentes fases do seu ciclo de desenvolvimento. Por exemplo, o tipo de compilação de depuração oferece opções de depuração e assina o APK com a chave de depuração, enquanto o tipo de compilação de lançamento pode reduzir, ofuscar e assinar seu APK com uma chave de lançamento para distribuição. Você deve definir pelo menos um tipo de compilação para compilar seu aplicativo — o Android Studio cria os tipos de compilação de depuração e lançamento por padrão. Para começar a personalizar as configurações de empacotamento do seu aplicativo, veja como Configurar tipos de compilação.
Variações de produtos
Variações de produtos representam diferentes versões do seu aplicativo que você pode lançar para os usuários, por exemplo, versões gratuita e paga do aplicativo. Você pode compartilhar e reutilizar partes comuns a todas as versões do aplicativo para personalizar variações de produtos para utilizar diferentes códigos e recursos. Variações de produtos são opcionais e devem ser criadas manualmente. Para começar a criar diferentes versões do seu aplicativo, veja como Configurar variações de produtos.
Variantes de compilação
Variante de compilação é um produto combinado de um tipo de compilação e uma variação de produto. Essa é a configuração que o Gradle usa para compilar seu aplicativo. Com as variantes de compilação, é possível compilar a versão de depuração das suas variações de produtos durante o desenvolvimento ou versões de lançamento assinadas das suas variações de produtos para distribuição. Apesar de não ser necessário configurar as variantes de compilação diretamente, é preciso configura os tipos de compilação e as variações de produtos que as formam. Criar tipos de compilação ou variações de produtos adicionais também faz com que variantes de compilação adicionais sejam criadas. Para saber como criar e gerenciar variantes de compilação, leia a visão geral de como Configurar variantes de compilação.
Entradas do manifesto
Você pode especificar valores para algumas propriedades do arquivo de manifesto na configuração da variante de compilação. Esses valores de compilação modificam os valores existentes do arquivo de manifesto. Isso é útil se você deseja gerar vários APKs para seus módulos, com cada arquivo .apk tendo valores diferentes para o nome do aplicativo, a versão mínima do SDK ou a versão de destino do SDK. Quando vários manifestos estiverem presentes, o Gradle mescla as configurações de manifesto.
Dependências
O sistema de compilação gerencia as dependências do projeto por meio de seu sistema de arquivos local e de repositórios remotos. Isso evita a necessidade de pesquisar, baixar e copiar manualmente os pacotes binários das suas dependências para o diretório do projeto. Para saber mais, veja como Declarar dependências.
Assinaturas
O sistema de compilação permite especificar configurações de assinatura nas configurações de compilação e ele pode assinar seus APKs automaticamente durante o processo de compilação. O sistema assina a versão de depuração com uma chave e um certificado padrão, usando credenciais conhecidas para evitar solicitações de senha no momento da compilação. Além disso, o sistema não assina a versão de lançamento a não ser que você defina uma configuração de assinatura explicitamente para essa compilação. Caso não tenha uma chave de lançamento, você pode gerar uma conforme a descrição apresentada em Assine seu aplicativo.
ProGuard
O sistema de compilação permite que você especifique um arquivo de regras do ProGuard diferente para cada variante de compilação. O sistema pode executar o ProGuard para reduzir e ofuscar suas classes durante o processo de compilação.
Divisões de APK
O sistema de compilação permite compilar automaticamente diferentes APKs, cada um contendo apenas os códigos e recursos necessários para uma densidade de tela ou interface binária de aplicativo (ABI) específica. Para saber mais, consulte Configure divisões de APK.

Arquivos de configuração de compilação

Para criar configurações de compilação personalizadas, você deve fazer alterações em um ou mais arquivos de configuração de compilação ou arquivos build.gradle. Esses arquivos de texto sem formatação usam a Domain Specific Language (DSL) para descrever e manipular a lógica de compilação que usa Groovy, que é uma linguagem dinâmica para a máquina virtual Java (JVM). Não é preciso conhecer Groovy para começar a configurar sua compilação, pois o Android Plugin for Gradle introduz a maioria dos elementos DSL de que você precisará. Para saber mais sobre a DSL do plug-in do Android, leia a documentação de referência de DSL.

Ao iniciar um novo projeto, o Android Studio automaticamente cria alguns desses arquivos para você, conforme é mostrado na figura 2, e os preenche com base em padrões razoáveis.

Figura 2. A estrutura de projeto padrão para um módulo de aplicativo Android.

Existem alguns arquivos de configuração de compilação do Gradle que fazem parte da estrutura de projeto padrão de um aplicativo Android. Antes de começar a configurar sua compilação, é importante entender o escopo e o propósito de cada um desses arquivos e os elementos DSL que eles devem definir.

O arquivo de configurações do Gradle

O arquivo settings.gradle, localizado no diretório-raiz do projeto, informa ao Gradle quais módulos ele deve incluir ao compilar seu aplicativo. Para a maioria dos projetos, o arquivo é simples e inclui apenas o elemento a seguir:

include ‘:app’

Entretanto, projetos com vários módulos devem especificar cada módulo que deve ser incluído na compilação final.

O arquivo de compilação de nível mais alto

O arquivo build.gradle de nível mais alto, localizado no diretório-raiz do projeto, define configurações de compilação que se aplicam a todos os módulos do seu projeto. Por padrão, o arquivo de compilação de nível mais alto usa o bloco buildscript {} para definir os repositórios e as dependências do Gradle que são comuns a todos os módulos do projeto. O exemplo de código a seguir descreve as configurações padrão e os elementos DSL que podem ser encontrados no arquivo build.gradle de nível mais alto após a criação de um novo projeto.

/**
 * The buildscript {} block is where you configure the repositories and
 * dependencies for Gradle itself--meaning, you should not include dependencies
 * for your modules here. For example, this block includes the Android plugin for
 * Gradle as a dependency because it provides the additional instructions Gradle
 * needs to build Android app modules.
 */

buildscript {

    /**
     * The repositories {} block configures the repositories Gradle uses to
     * search or download the dependencies. Gradle pre-configures support for remote
     * repositories such as JCenter, Maven Central, and Ivy. You can also use local
     * repositories or define your own remote repositories. The code below defines
     * JCenter as the repository Gradle should use to look for its dependencies.
     */

    repositories {
        jcenter()
    }

    /**
     * The dependencies {} block configures the dependencies Gradle needs to use
     * to build your project. The following line adds Android Plugin for Gradle
     * version 3.0.1 as a classpath dependency.
     */

    dependencies {
        classpath 'com.android.tools.build:gradle:3.0.1'
    }
}

/**
 * The allprojects {} block is where you configure the repositories and
 * dependencies used by all modules in your project, such as third-party plugins
 * or libraries. Dependencies that are not required by all the modules in the
 * project should be configured in module-level build.gradle files. For new
 * projects, Android Studio configures JCenter as the default repository, but it
 * does not configure any dependencies.
 */

allprojects {
   repositories {
       jcenter()
   }
}

O arquivo de compilação de módulo

O arquivo build.gradle de módulo, localizado em cada diretório <project>/<module>/, permite definir configurações de compilação para o módulo específico no qual ele se encontra. Definir essas configurações de compilação permite fornecer opções de empacotamento personalizadas, como tipos de compilação e variações de produtos adicionais, além de modificar as configurações no manifesto de aplicativo main/ ou do arquivo build.gradle de nível mais alto.

Este arquivo build.gradle de módulo do exemplo de aplicativo Android descreve alguns dos elementos DSL básicos e das configurações que você deve conhecer.

/**
 * The first line in the build configuration applies the Android plugin for
 * Gradle to this build and makes the android {} block available to specify
 * Android-specific build options.
 */

apply plugin: 'com.android.application'

/**
 * The android {} block is where you configure all your Android-specific
 * build options.
 */

android {

  /**
   * compileSdkVersion specifies the Android API level Gradle should use to
   * compile your app. This means your app can use the API features included in
   * this API level and lower.
   *
   * buildToolsVersion specifies the version of the SDK build tools, command-line
   * utilities, and compiler that Gradle should use to build your app. You need to
   * download the build tools using the SDK Manager.
   */

  compileSdkVersion 26
  buildToolsVersion "26.0.2"

  /**
   * The defaultConfig {} block encapsulates default settings and entries for all
   * build variants, and can override some attributes in main/AndroidManifest.xml
   * dynamically from the build system. You can configure product flavors to override
   * these values for different versions of your app.
   */

  defaultConfig {

    /**
     * applicationId uniquely identifies the package for publishing.
     * However, your source code should still reference the package name
     * defined by the package attribute in the main/AndroidManifest.xml file.
     */

    applicationId 'com.example.myapp'

    // Defines the minimum API level required to run the app.
    minSdkVersion 15

    // Specifies the API level used to test the app.
    targetSdkVersion 26

    // Defines the version number of your app.
    versionCode 1

    // Defines a user-friendly version name for your app.
    versionName "1.0"
  }

  /**
   * The buildTypes {} block is where you can configure multiple build types.
   * By default, the build system defines two build types: debug and release. The
   * debug build type is not explicitly shown in the default build configuration,
   * but it includes debugging tools and is signed with the debug key. The release
   * build type applies Proguard settings and is not signed by default.
   */

  buildTypes {

    /**
     * By default, Android Studio configures the release build type to enable code
     * shrinking, using minifyEnabled, and specifies the Proguard settings file.
     */

    release {
        minifyEnabled true // Enables code shrinking for the release build type.
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
  }

  /**
   * The productFlavors {} block is where you can configure multiple product
   * flavors. This allows you to create different versions of your app that can
   * override defaultConfig {} with their own settings. Product flavors are
   * optional, and the build system does not create them by default. This example
   * creates a free and paid product flavor. Each product flavor then specifies
   * its own application ID, so that they can exist on the Google Play Store, or
   * an Android device, simultaneously.
   */

  productFlavors {
    free {
      applicationId 'com.example.myapp.free'
    }

    paid {
      applicationId 'com.example.myapp.paid'
    }
  }

  /**
   * The splits {} block is where you can configure different APK builds that
   * each contain only code and resources for a supported screen density or
   * ABI. You'll also need to configure your build so that each APK has a
   * different versionCode.
   */

  splits {
    // Screen density split settings
    density {

      // Enable or disable the density split mechanism
      enable false

      // Exclude these densities from splits
      exclude "ldpi", "tvdpi", "xxxhdpi", "400dpi", "560dpi"
    }
  }
}

/**
 * The dependencies {} block in the module-level build configuration file
 * only specifies dependencies required to build the module itself.
 */

dependencies {
    compile project(":lib")
    compile 'com.android.support:appcompat-v7:27.0.2'
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

Arquivos de propriedade do Gradle

O Gradle também contém dois arquivos de propriedades, localizados no diretório-raiz do seu projeto, úteis para especificar configurações para o próprio kit de ferramentas de compilação do Gradle:

gradle.properties
Nesse arquivo, é possível definir configurações do Gradle para todo o projeto, como o tamanho máximo de heap do daemon do Gradle. Para saber mais, consulte O ambiente de compilação.
local.properties
Esse arquivo configura as propriedades de ambiente local do sistema de compilação, como o caminho da instalação do SDK. Como o conteúdo desse arquivo é gerado automaticamente pelo Android Studio e é específico ao ambiente de desenvolvedor local, você não deve modificá-lo manualmente ou inseri-lo em seu sistema de controle de versões.

Como sincronizar o projeto com arquivos do Gradle

Quando você faz alterações nos arquivos de configuração de compilação do seu projeto, o Android Studio exige a sincronização dos arquivos do projeto para permitir a importação das alterações e a execução de algumas verificações para garantir que as configurações não criem erros de compilação.

Para sincronizar os arquivos do projeto, clique em Sync Now na barra de notificações exibida ao fazer alterações, conforme é mostrado na figura 3, ou clique em Sync Project na barra de menu. Se o Android Studio perceber erros em sua configuração, por exemplo, se o código-fonte usar recursos de API que só estão disponíveis em um nível de API superior à sua compileSdkVersion, a janela Messages será exibida com uma descrição do problema.

Figura 3. Sincronizando o projeto com arquivos de configuração de compilação no Android Studio.

Conjuntos de origem

O Android Studio agrupa o código-fonte e os recursos de maneira lógica para cada módulo, criando conjuntos de origem. O conjunto de origem main/ de um módulo contém os códigos e os recursos usados por todas as suas variantes de compilação. Diretórios de conjuntos de origem adicionais são opcionais, e o Android Studio não os cria automaticamente quando você configura novas variantes de compilação. Entretanto, a criação de conjuntos de origem, semelhante ao main/, ajuda a organizar os arquivos e recursos que o Gradle só deve usar ao compilar certas versões do seu aplicativo:

src/main/
Esse conjunto de origem inclui os códigos e recursos comuns a todas as variantes de compilação.
src/<buildType>/
Crie esse conjunto de origem para incluir os códigos e recursos exclusivos de um tipo de compilação específico.
src/<productFlavor>/
Crie esse conjunto de origem para incluir os códigos e recursos exclusivos de uma variação de produto específica.
src/<productFlavorBuildType>/
Crie esse conjunto de origem para incluir os códigos e recursos exclusivos de uma variante de compilação específica.

Por exemplo, para gerar a versão "fullDebug" do seu aplicativo, o sistema de compilação mescla códigos, configurações e recursos dos seguintes conjuntos de origem:

Observação: ao criar um novo arquivo ou diretório no Android Studio usando as opções de menu File > New, você pode criá-lo para um conjunto de origem específico. Os conjuntos de origem a escolher se baseiam nas configurações de compilação, e o Android Studio cria os diretórios necessários automaticamente se eles ainda não existirem.

Se conjuntos de origem diferentes contiverem versões diferentes do mesmo arquivo, o Gradle usará a seguinte ordem de prioridade ao decidir qual arquivo usar (os conjuntos de origem à esquerda modificam os arquivos e as configurações dos conjuntos de origem à direita):

variante de compilação > tipo de compilação > variação de produto > conjunto de origem principal > dependências de biblioteca

Isso permite que o Gradle use arquivos específicos à variante de compilação que você está tentando compilar reutilizando atividades, lógica de aplicativo e recursos comuns a outras versões do aplicativo. Ao mesclar diversos manifestos, o Gradle usa a mesma ordem de prioridade, portanto cada variante de compilação pode definir diferentes componentes ou permissões no manifesto final. Para saber mais sobre como criar conjuntos de origem personalizados, acesse Crie conjuntos de origem para variantes de compilação.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience.
(Sep 2017 survey)