Configurar o Android Studio

O Android Studio oferece assistentes e modelos para verificar os requisitos de sistema, como o Java Development Kit (JDK) e a RAM disponível, assim como para definir configurações padrão, como uma emulação de Android Virtual Device (AVD) otimizada padrão e imagens de sistema atualizadas. Este documento descreve as definições de configuração adicionais que você poderá usar para personalizar o uso do Android Studio.

O Android Studio oferece acesso a dois arquivos de configuração por meio do menu Help:

  • studio.vmoptions: personalize opções para a máquina virtual Java (JVM) do Studio, como tamanho da heap e do cache. Nas máquinas Linux, esse arquivo pode ser chamado de studio64.vmoptions, dependendo da versão do Android Studio.
  • idea.properties: personalize propriedades do Android Studio, como o caminho da pasta de plug-ins ou o tamanho máximo de arquivo permitido.

Para a documentação específica sobre a configuração e o uso do emulador e do dispositivo, consulte os seguintes tópicos:

Encontrar os arquivos de configuração

Os dois arquivos de configuração são armazenados na pasta de configuração do Android Studio. O nome da pasta depende da versão do Studio. Por exemplo, o Android Studio 3.3 tem o nome de pasta AndroidStudio3.3. A localização da pasta depende do sistema operacional:

  • Windows: %USERPROFILE%\.CONFIGURATION_FOLDER
  • macOS: ~/Library/Preferences/CONFIGURATION_FOLDER
  • Linux: ~/.CONFIGURATION_FOLDER

Você também pode usar as variáveis de ambiente a seguir para apontar para arquivos de modificação específicos em outros lugares:

  • STUDIO_VM_OPTIONS: defina o nome e o local do arquivo .vmoptions
  • STUDIO_PROPERTIES: defina o nome e o local do arquivo .properties
  • STUDIO_JDK: defina o JDK a ser usado para executar o Studio

Personalizar opções da VM

O arquivo studio.vmoptions permite personalizar opções para a JVM do Android Studio. Para aumentar o desempenho do Studio, a opção mais comum é ajustar o tamanho máximo de heap, mas também é possível usar o arquivo studio.vmoptions para modificar outras configurações padrão, como tamanho inicial de heap, tamanho do cache e chaves de coleta de lixo do Java.

Para criar um novo arquivo studio.vmoptions ou para abrir o arquivo existente, realize as seguintes etapas:

  1. Clique em Help > Edit Custom VM Options. Se você nunca editou opções de VM para o Android Studio antes, o ambiente de desenvolvimento integrado solicitará que você crie um novo arquivo studio.vmoptions. Clique em Yes para criar o arquivo.
  2. O arquivo studio.vmoptions é aberto na janela do editor do Android Studio. Edite o arquivo para adicionar suas próprias opções personalizadas de VM. Para uma lista completa das opções personalizáveis da JVM, consulte a página Java HotSpot VM Options da Oracle (em inglês).

O arquivo studio.vmoptions criado é adicionado ao arquivo studio.vmoptions padrão, localizado no diretório bin/ dentro da pasta de instalação do Android Studio.

Você nunca deve editar diretamente o arquivo studio.vmoptions localizado na pasta do programa Android Studio. Embora seja possível acessar o arquivo para ver as opções padrão de VM do Studio, edite apenas seu próprio arquivo studio.vmoptions para garantir que você não modifique configurações padrão importantes do Android Studio. Portanto, no arquivo studio.vmoptions, modifique somente os atributos desejados e permita que o Android Studio continue usando valores padrão para todos os atributos não alterados.

Tamanho máximo de heap

Por padrão, o tamanho máximo de heap do Android Studio é 1.280 MB. Se você está trabalhando em um projeto grande ou se o sistema tem bastante RAM disponível, é possível melhorar o desempenho aumentando o tamanho máximo de heap nas opções de VM do Android Studio. Se o sistema tem restrições de memória, pode ser necessário reduzir o tamanho máximo de heap.

Para alterar o tamanho máximo de heap, siga estas etapas:

  1. Clique em Help > Edit Custom VM Options para abrir o arquivo studio.vmoptions.
  2. Adicione uma linha ao arquivo studio.vmoptions para definir o tamanho máximo de heap usando a sintaxe -XmxheapSize. O tamanho escolhido precisa ser baseado no tamanho do projeto e na RAM disponível na máquina. Como referência, se você tiver mais de 4 GB de RAM e um projeto de tamanho médio, defina o tamanho máximo de heap para 2 GB ou mais. As linhas a seguir definem o tamanho máximo de heap como 2 GB:

    -Xmx2g
        
  3. Salve as alterações no arquivo studio.vmoptions e reinicie o Android Studio para que as alterações entrem em vigor.

  4. Para confirmar o novo tamanho máximo de heap, abra a linha de comando e digite este comando:

        $ jps -lvm
        

    Será exibida uma lista de JVMs instrumentadas executadas na máquina, incluindo o nome do pacote completo de cada uma e os argumentos passados. Localize o item correspondente à instância do Android Studio. O nome precisa terminar com -Didea.paths.selector=AndroidStudio[Version]. Essa JVM precisa ter dois argumentos com o nome começando por -Xmx, um com o valor padrão de 1.280 MB e o outro com o novo valor, como mostrado na Figura 1.

    Figura 1. A saída do terminal mostrando os argumentos atuais da JVM do Android Studio.

    1. O argumento -Xmx mostrando o tamanho máximo de heap padrão, neste caso, 1.280 MB.
    2. O -Didea.paths.selector mostrando a versão do Android Studio em execução no momento.
    3. O argumento -Xmx mostrando o novo tamanho máximo de heap personalizado. Observe que logo em seguida é mostrado o local do arquivo studio.vmoptions personalizado criado acima.

Exportar e importar configurações do ambiente de desenvolvimento integrado

Você pode exportar um arquivo Settings.jar com todas ou um subconjunto das suas configurações preferidas de ambiente de desenvolvimento integrado para um projeto. Esse arquivo JAR poderá ser importado para outros projetos e/ou disponibilizado para importação pelos seus colegas nos projetos deles.

Para mais informações, consulte Exportar e importar configurações no IntelliJ IDEA (link em inglês).

Personalizar propriedades do ambiente de desenvolvimento integrado

O arquivo idea.properties permite que você personalize as propriedades do ambiente de desenvolvimento integrado para o Android Studio, como o caminho para os plug-ins instalados pelo usuário e o tamanho máximo de arquivo compatível com esse ambiente. O arquivo idea.properties é mesclado com as propriedades padrão do ambiente de desenvolvimento integrado para que você possa especificar apenas as propriedades de modificação.

Para criar um novo arquivo idea.properties ou abrir o arquivo existente, realize as seguintes etapas:

  1. Clique em Help > Edit Custom Properties. Se você nunca editou as propriedades do ambiente de desenvolvimento integrado, o Android Studio solicitará a criação de um novo arquivo idea.properties. Clique em Yes para criar o arquivo.
  2. O arquivo idea.properties é aberto na janela do editor do Android Studio. Edite o arquivo para adicionar suas propriedades personalizadas de ambiente de desenvolvimento integrado.

O arquivo idea.properties a seguir inclui as propriedades de ambiente de desenvolvimento integrado habitualmente personalizadas. Para uma lista completa de propriedades, leia sobre o arquivo idea.properties para IntelliJ IDEA (link em inglês).

#---------------------------------------------------------------------
    # Uncomment this option if you want to customize path to user installed plugins folder. Make sure
    # you're using forward slashes.
    #---------------------------------------------------------------------
    # idea.plugins.path=${idea.config.path}/plugins
    #---------------------------------------------------------------------
    # Maximum file size (kilobytes) IDE should provide code assistance for.
    # The larger file is the slower its editor works and higher overall system memory requirements are
    # if code assistance is enabled. Remove this property or set to very large number if you need
    # code assistance for any files available regardless their size.
    #---------------------------------------------------------------------
    idea.max.intellisense.filesize=2500
    #---------------------------------------------------------------------
    # This option controls console cyclic buffer: keeps the console output size not higher than the
    # specified buffer size (Kb). Older lines are deleted. In order to disable cycle buffer use
    # idea.cycle.buffer.size=disabled
    #---------------------------------------------------------------------
    idea.cycle.buffer.size=1024
    #---------------------------------------------------------------------
    # Configure if a special launcher should be used when running processes from within IDE.
    # Using Launcher enables "soft exit" and "thread dump" features
    #---------------------------------------------------------------------
    idea.no.launcher=false
    #---------------------------------------------------------------------
    # To avoid too long classpath
    #---------------------------------------------------------------------
    idea.dynamic.classpath=false
    #---------------------------------------------------------------------
    # There are two possible values of idea.popup.weight property: "heavy" and "medium".
    # If you have WM configured as "Focus follows mouse with Auto Raise" then you have to
    # set this property to "medium". It prevents problems with popup menus on some
    # configurations.
    #---------------------------------------------------------------------
    idea.popup.weight=heavy
    #---------------------------------------------------------------------
    # Use default anti-aliasing in system, i.e. override value of
    # "Settings|Editor|Appearance|Use anti-aliased font" option. May be useful when using Windows
    # Remote Desktop Connection for instance.
    #---------------------------------------------------------------------
    idea.use.default.antialiasing.in.editor=false
    #---------------------------------------------------------------------
    # Disabling this property may lead to visual glitches like blinking and fail to repaint
    # on certain display adapter cards.
    #---------------------------------------------------------------------
    sun.java2d.noddraw=true
    #---------------------------------------------------------------------
    # Removing this property may lead to editor performance degradation under Windows.
    #---------------------------------------------------------------------
    sun.java2d.d3d=false
    #---------------------------------------------------------------------
    # Workaround for slow scrolling in JDK6
    #---------------------------------------------------------------------
    swing.bufferPerWindow=false
    #---------------------------------------------------------------------
    # Removing this property may lead to editor performance degradation under X Window.
    #---------------------------------------------------------------------
    sun.java2d.pmoffscreen=false
    #---------------------------------------------------------------------
    # Workaround to avoid long hangs while accessing clipboard under Mac OS X.
    #---------------------------------------------------------------------
    # ide.mac.useNativeClipboard=True
    #---------------------------------------------------------------------
    # Maximum size (kilobytes) IDEA will load for showing past file contents -
    # in Show Diff or when calculating Digest Diff
    #---------------------------------------------------------------------
    # idea.max.vcs.loaded.size.kb=20480
    

Configurar o ambiente de desenvolvimento integrado para máquinas com pouca memória

Se estiver executando o Android Studio em uma máquina com especificações inferiores às recomendadas (consulte Requisitos do sistema), você poderá personalizar o ambiente de desenvolvimento integrado para aumentar o desempenho na máquina, da seguinte forma:

  • Reduza o tamanho de heap máximo disponível para o Android Studio: reduza o tamanho de heap máximo do Android Studio para 512 MB. Para mais informações sobre a alteração do tamanho de heap máximo, consulte Tamanho de heap máximo.
  • Atualize o Gradle e o plug-in do Android para Gradle: atualize para as versões mais recentes do Gradle e do plug-in do Android para Gradle para garantir o uso dos aprimoramentos de desempenho mais recentes. Para mais informações sobre a atualização do Gradle e do plug-in do Android para Gradle, consulte as Notas da versão do plug-in do Android para Gradle.
  • Ative o modo de economia de energia: a ativação do modo de economia de energia desliga diversas operações de segundo plano que fazem uso intenso de memória e bateria, incluindo realce de erros e inspeções em tempo real, pop-up automático de conclusão de código e compilação incremental automática em segundo plano. Para ativar o modo de economia de energia, clique em File > Power Save Mode.
  • Desative verificações desnecessárias de lint: para alterar quais verificações de lint o Android Studio executa no seu código, faça o seguinte:

    1. Clique em File > Settings (no macOS, Android Studio > Preferences) para abrir a caixa de diálogo Settings.
    2. No painel esquerdo, expanda a seção Editor e clique em Inspections.
    3. Clique nas caixas de seleção para marcar ou desmarcar verificações de lint de acordo com as necessidades do projeto.
    4. Clique em Apply ou OK para salvar as alterações.
  • Depure em um dispositivo físico: a depuração em um emulador usa mais memória do que depuração em um dispositivo físico. Assim, você pode melhorar o desempenho geral do Android Studio depurando em um dispositivo físico.

  • Inclua apenas os serviços necessários do Google Play como dependências: incluir o Google Play Services como dependências no seu projeto aumenta a quantidade de memória necessária. Inclua apenas as dependências necessárias para melhorar o uso de memória e o desempenho. Para mais informações, consulte Adicionar o Google Play Services ao projeto.

  • Ative o modo off-line para o Gradle? se você tiver largura de banda limitada, ative o modo off-line para evitar que o Gradle tente fazer o download de dependências ausentes durante a compilação. Quando o modo off-line está ativado, o Gradle emite um erro de compilação se houver dependências ausentes, em vez de tentar fazer o download delas. Para ativar o modo off-line, faça o seguinte:

    1. Clique em File > Settings (no macOS, Android Studio > Preferences) para abrir a caixa de diálogo Settings.
    2. No painel esquerdo, expanda Build, Execution, Deployment e clique em Gradle.
    3. Em "Global Gradle settings", marque a caixa de seleção Offline work.
    4. Clique em Apply ou OK para que as alterações entrem em vigor.
  • Reduza o tamanho de heap máximo disponível para o Gradle: o tamanho de heap máximo padrão do Gradle é de 1.536 MB. Reduza o valor modificando a propriedade org.gradle.jvmargs no arquivo gradle.properties, conforme mostrado abaixo:

    # Make sure to gradually decrease this value and note
        # changes in performance. Allocating too lttle memory may
        # also decrease performance.
        org.gradle.jvmargs = -Xmx1536m
        
  • Não ative a compilação paralela: o Android Studio pode compilar módulos independentes em paralelo. No entanto, se você tiver um sistema com pouca memória, não ative esse recurso. Para verificar essa configuração, faça o seguinte:

    1. Clique em File > Settings (no macOS, Android Studio > Preferences) para abrir a caixa de diálogo Settings.
    2. No painel esquerdo, expanda Build, Execution, Deployment e clique em Compiler.
    3. Verifique se a opção Compile independent modules in parallel está desmarcada.
    4. Se você fez uma alteração, clique em Apply ou OK para que a alteração entre em vigor.

Configurar o projeto para o Instant Run

Instant Run é um comportamento para os comandos Run e Debug que reduz significativamente o tempo entre as atualizações do seu app. Mesmo que sua primeira compilação demore mais para ser concluída, o Instant Run envia atualizações subsequentes ao seu app sem compilar um novo APK. Assim, as alterações podem ser vistas com muito mais rapidez.

O Android Studio ativa o Instant Run por padrão para projetos compilados usando o plug-in do Android para Gradle 2.0.0 ou versão posterior. É possível aumentar o desempenho da compilação com o Instant Run modificando algumas configurações do projeto. Para ver mais informações sobre como configurar seu projeto para o Instant Run, consulte Configurar e otimizar seu projeto para o Instant Run.

Definir a versão do JDK

Uma cópia do OpenJDK mais recente é fornecida empacotada com o Android Studio 2.2 ou versão posterior. Essa é a versão de JDK recomendada para uso com projetos Android. Para usar o JDK empacotado, faça o seguinte:

  1. Abra o projeto no Android Studio e selecione File > Project Structure na barra de menus.
  2. Na página SDK Location, em JDK location, marque a caixa de seleção Use embedded JDK.
  3. Clique em OK.

Por padrão, a versão da linguagem Java usada para compilar o projeto é baseada na compileSdkVersion do projeto (porque versões diferentes do Android são compatíveis com versões distintas do Java). Se necessário, você pode modificar essa versão Java padrão adicionando o seguinte bloco CompileOptions {} ao arquivo build.gradle:

android {
        compileOptions {
            sourceCompatibility JavaVersion.VERSION\_1\_6
            targetCompatibility JavaVersion.VERSION\_1\_6
        }
    }
    

Para ver mais informações sobre onde compileSdkVersion é definido, leia sobre o arquivo de compilação de nível de módulo.

Definir configurações do proxy

Os proxies atuam como pontos de conexão intermediários entre clientes HTTP e servidores da Web que adicionam segurança e privacidade às conexões de Internet.

Para que haja compatibilidade com a execução do Android Studio protegida por um firewall, defina as configurações de proxy para o ambiente de desenvolvimento integrado do Android Studio. Use a página de configurações para o proxy HTTP do ambiente de desenvolvimento integrado do Android Studio para fazer isso.

Para executar o plug-in do Android para Gradle na linha de comando ou em máquinas em que o Android Studio não foi instalado, como servidores de integração contínua, defina as configurações do proxy no arquivo de compilação do Gradle.

Configurar o proxy do Android Studio

O Android Studio é compatível com configurações de proxy HTTP para que você possa executá-lo com a proteção de um firewall ou de uma rede segura. Para definir as configurações de proxy HTTP no Android Studio:

  1. Na barra de menus, clique em File > Settings (no macOS, clique em Android Studio > Preferences).
  2. No painel esquerdo, clique em Appearance & Behavior > System Settings > HTTP Proxy. A página de proxy HTTP será exibida.
  3. Selecione Auto-detect proxy settings para usar um URL de configuração automática de proxy para as configurações de proxy, ou Manual proxy configuration para inserir manualmente todas as configurações. Para ver uma explicação detalhada dessas configurações, consulte {Proxy HTTP (link em inglês).
  4. Clique em Apply ou OK para que as alterações entrem em vigor.

Configurações de proxy HTTP para o plug-in Android para Gradle

Para executar o plug-in do Android na linha de comando ou em máquinas em que o Android Studio não esteja instalado, defina as configurações de proxy do plug-in do Android para Gradle no arquivo de compilação do Gradle.

Para configurações de proxy HTTP específicas de aplicativos, defina as configurações de proxy no arquivo build.gradle de acordo com cada módulo do aplicativo.

apply plugin: 'com.android.application'

    android {
        ...

        defaultConfig {
            ...
            systemProp.http.proxyHost=proxy.company.com
            systemProp.http.proxyPort=443
            systemProp.http.proxyUser=userid
            systemProp.http.proxyPassword=password
            systemProp.http.auth.ntlm.domain=domain
        }
        ...
    }
    

Para configurações de proxy HTTP para todo o projeto, defina as configurações de proxy no arquivo gradle/gradle.properties.

# Project-wide Gradle settings.
    ...

    systemProp.http.proxyHost=proxy.company.com
    systemProp.http.proxyPort=443
    systemProp.http.proxyUser=username
    systemProp.http.proxyPassword=password
    systemProp.http.auth.ntlm.domain=domain

    systemProp.https.proxyHost=proxy.company.com
    systemProp.https.proxyPort=443
    systemProp.https.proxyUser=username
    systemProp.https.proxyPassword=password
    systemProp.https.auth.ntlm.domain=domain

    ...
    

Para informações sobre o uso de propriedades do Gradle para configurações de proxy, consulte o Guia do usuário do Gradle (link em inglês).

Otimizar o desempenho do Android Studio no Windows

O desempenho do Android Studio no Windows pode ser afetado por diversos fatores. Esta seção descreve como você pode otimizar as configurações do Android Studio para ter o melhor desempenho possível no Windows.

Minimizar o impacto do software antivírus na velocidade de compilação

Alguns softwares antivírus podem interferir no processo de compilação do Android Studio, fazendo com que as compilações sejam executadas de maneira muito mais lenta. Quando você executa uma versão no Android Studio, o Gradle compila os recursos e o código-fonte do seu app e, em seguida, agrupa os recursos compilados em um APK. Durante esse processo, muitos arquivos são criados no seu computador. Se seu software antivírus estiver habilitado para verificação em tempo real, o antivírus poderá forçar a interrupção do processo de compilação sempre que um arquivo for criado enquanto o antivírus verifica esse arquivo.

Para evitar esse problema, você pode excluir determinados diretórios da verificação em tempo real do software antivírus.

A lista a seguir mostra o local padrão de cada diretório do Android Studio que você precisa excluir da verificação em tempo real:

Cache do Gradle
%USERPROFILE%\.gradle
Projetos do Android Studio
%USERPROFILE%\AndroidStudioProjects
SDK do Android
%USERPROFILE%\AppData\Local\Android\SDK
Arquivos de sistema do Android Studio
C:\Program Files\Android\Android Studio\system

Personalizar locais de diretório para ambientes controlados pela Política de grupo

Se uma Política de grupo limitar os diretórios que você pode excluir da verificação em tempo real no seu computador, mova os diretórios do Android Studio para um dos locais que a Política de grupo centralizada já exclui.

A lista a seguir mostra como personalizar o local de cada diretório do Android Studio, onde C:\WorkFolder é o diretório que a Política de grupo já exclui:

Cache do Gradle
Defina a variável de ambiente GRADLE_USER_HOME para apontar para C:\WorkFolder\.gradle.
Projetos do Android Studio
Mova ou crie diretórios de projeto em um subdiretório apropriado de C:\WorkFolder. Por exemplo, C:\WorkFolder\AndroidStudioProjects.
SDK do Android

Siga estas etapas:

  1. No Android Studio, abra a caixa de diálogo Settings (Preferences no macOS) e navegue até Appearance & Behavior > System Settings > Android SDK.

  2. Altere o valor de Android SDK Location para C:\WorkFolder\AndroidSDK.

    Para evitar o download do SDK novamente, copie o diretório existente do SDK, localizado em %USERPROFILE%\AppData\Local\Android\SDK por padrão, para o novo local.

Arquivos de sistema do Android Studio

Siga estas etapas:

  1. No Android Studio, clique em Help > Edit Custom Properties.

    O Android Studio solicita que você crie um arquivo idea.properties se ainda não tiver um.

  2. Adicione a seguinte linha ao arquivo idea.properties:

        idea.system.path=c:/workfolder/studio/caches/trunk-system
        

Configurar dependências de compilação off-line

Se você quiser criar seu projeto sem uma conexão de rede, siga as etapas abaixo para configurar o ambiente de desenvolvimento integrado para usar as versões off-line do Android Gradle Plugin e as dependências do Google Maven.

Caso você ainda não tenha feito isso, faça o download dos componentes off-line na página de downloads.

Fazer o download dos componentes off-line e descompactá-los

Depois de fazer o download dos componentes off-line, descompacte o conteúdo deles no diretório a seguir, que talvez você precise criar se ainda não existir:

  • No Windows: %USER_HOME%/.android/manual-offline-m2/
  • No macOS e no Linux: ~/.android/manual-offline-m2/

Para atualizar os componentes off-line, faça o seguinte: 1. Exclua o conteúdo dentro do diretório manual-offline-m2/. 1. Faça novamente o download dos componentes off-line. 1. Descompacte o conteúdo dos arquivos ZIP que você transferiu por download para o diretório manual-offline-m2/.

Incluir componentes off-line no seu projeto do Gradle

Para que o sistema de compilação do Android use os componentes off-line que você transferiu por download e descompactou, é necessário criar um script, conforme descrito abaixo. Lembre-se de que você precisa criar e salvar esse script apenas uma vez, mesmo depois de atualizar os componentes off-line.

  1. Crie um arquivo de texto vazio com o seguinte caminho e nome de arquivo:
    • No Windows: %USER_HOME%/.gradle/init.d/offline.gradle
    • No macOS e no Linux: ~/.gradle/init.d/offline.gradle
  2. Abra o arquivo de texto e inclua o seguinte script:

    def reposDir = new File(System.properties['user.home'], ".android/manual-offline-m2")
        def repos = new ArrayList()
        reposDir.eachDir {repos.add(it) }
        repos.sort()
    
        allprojects {
          buildscript {
            repositories {
              for (repo in repos) {
                maven {
                  name = "injected_offline_${repo.name}"
                  url = repo.toURI().toURL()
                }
              }
            }
          }
          repositories {
            for (repo in repos) {
              maven {
                name = "injected_offline_${repo.name}"
                url = repo.toURI().toURL()
              }
            }
          }
        }
        
  3. Salve o arquivo de texto.

  4. (Opcional) Se você quiser verificar se os componentes off-line funcionam como previsto, remova os repositórios on-line dos arquivos build.gradle do projeto, conforme mostrado abaixo. Depois de confirmar que seu projeto foi compilado corretamente sem esses repositórios, você pode colocá-los novamente nos arquivos build.gradle.

    buildscript {
            repositories {
                // Hide these repositories to test your build against
                // the offline components. You can include them again after
                // you've confirmed that your project builds ‘offline’.
                // google()
                // jcenter()
            }
            ...
        }
        allprojects {
            repositories {
                // google()
                // jcenter()
            }
            ...
        }