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, e 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 pilha e do cache. Observe que, em máquinas Linux, esse arquivo pode ser denominado studio64.vmoptions, dependendo da versão do Android Studio.
  • idea.properties: personalize propriedades do Android Studio, como caminho da pasta de plug-ins ou tamanho máximo de arquivo permitido.

Para obter documentação específica sobre o emulador e a configuração e uso de dispositivos, consulte Gerenciamento de dispositivos virtuais, Usar dispositivos de hardware e Drivers USB OEM.

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, no Android Studio 2.2, o nome da pasta é AndroidStudio2.2. A localização da pasta depende do sistema operacional:

  • Windows: %USERPROFILE%\.<CONFIGURATION_FOLDER>/
  • Mac: ~/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 da pilha, mas também é possível usar o arquivo studio.vmoptions para modificar outras configurações padrão, como tamanho inicial da pilha, tamanho do cache e chaves de coleta de lixo do Java.

Para criar um novo arquivo studio.vmoptions ou abrir um arquivo existente, execute 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 IDE solicitará que crie um novo arquivo studio.vmoptions. Clique em Yes para criar o arquivo.
  2. O arquivo studio.vmoptions abre na janela do editor do Android Studio. Edite o arquivo para adicionar suas próprias opções personalizadas de VM. Para obter uma lista das opções personalizáveis da JVM, consulte a página Java HotSpot VM Options da Oracle.

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.

Observe que você nunca deve editar diretamente o arquivo studio.vmoptions encontrado dentro da pasta de programa do Android Studio. Embora seja possível acessar o arquivo para ver as opções padrão de VM do Studio, edite apenas o 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 da pilha

Por padrão, o tamanho máximo de pilha do Android Studio é 1.280 MB. Se estiver trabalhando em um projeto grande ou se o sistema tiver bastante RAM disponível, você poderá melhorar o desempenho aumentando o tamanho máximo da pilha 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 da pilha.

Para alterar o tamanho máximo da pilha, siga estas etapas:

  1. Clique em Help > Edit Custom VM Options para abrir o seu arquivo studio.vmoptions.
  2. Adicione uma linha ao arquivo studio.vmoptions para definir o tamanho máximo da pilha usando a sintaxe -XmxheapSize. O tamanho escolhido deve 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 da pilha para 2 GB ou mais. As linhas a seguir definem o tamanho máximo da pilha para 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 da pilha, 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 deve terminar com -Didea.paths.selector=AndroidStudio[Version]. Essa JVM deve ter dois argumentos com o nome começando por -Xmx, um com o valor padrão de 1280 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 da pilha padrão, neste caso, 1280m.
    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 da pilha personalizado. Observe que logo em seguida é mostrado o local do arquivo studio.vmoptions personalizado criado acima.

Exportar e importar configurações do IDE

Você pode exportar um arquivo JAR de configurações (Settings.jar) com todas ou um subconjunto de configurações de IDE preferidas para um projeto. Esse arquivo JAR poderá ser importado para outros projetos e/ou disponibilizado para importação pelos seus colegas em seus projetos.

Para obter mais informações, consulte Exportar e importar configurações no IntelliJ IDEA.

Personalizar propriedades do IDE

O arquivo idea.properties permite personalizar propriedades do IDE para o Android Studio, como o caminho para plug-ins instalados pelo usuário e o tamanho máximo de arquivo permitido pelo IDE. O arquivo idea.properties é combinado com as propriedades padrão do IDE, permitindo especificar apenas as propriedades modificadas.

Para criar um novo arquivo idea.properties ou abrir um já existente, execute as seguintes etapas:

  1. Clique em Help > Edit Custom Properties. Se você nunca editou as propriedades do IDE antes, 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 abre na janela do editor do Android Studio. Edite o arquivo para adicionar suas próprias opções personalizadas de IDE.

O arquivo idea.properties a seguir inclui as propriedades do IDE habitualmente personalizadas. Para obter uma lista completa de propriedades, leia sobre o arquivo idea.properties para o IntelliJ IDEA.

#---------------------------------------------------------------------
# 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 IDE 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 IDE para aumentar o desempenho na máquina, da seguinte forma:

  • Reduza o tamanho máximo da pilha disponível para o Android Studio: reduza o tamanho máximo da pilha do Android Studio para 512 MB. Para obter mais informações sobre a alteração do tamanho máximo da pilha, consulte Tamanho máximo da pilha.
  • Atualize o Gradle e o Android Plugin para Gradle: atualize para as versões mais recentes do Gradle e do Android Plugin para Gradle para garantir o uso dos aprimoramentos de desempenho mais recentes. Para obter mais informações sobre a atualização para o Gradle e o Android Plugin para Gradle, consulte as notas da versão do Android Plugin 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 intensivo 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 de lint desnecessárias: para alterar as verificações de lint executadas pelo Android Studio no código, faça o seguinte:
    1. Clique em File > Settings (em um Mac, 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 selecionar ou cancelar a seleção de 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 gasta mais memória que a executada em um dispositivo físico. Portanto, você pode aumentar o desempenho geral do Android Studio depurando em dispositivos físicos.
  • Inclua somente os Google Play Services necessários como dependências: a inclusão de Google Play Services como dependências no 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 obter mais informações, consulte Adicionar o Google Play Services ao projeto.
  • Ative o modo off-line do 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 (em um Mac, 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 máximo da pilha disponível para a compilação de arquivos DEX: defina javaMaxHeapSize para compilação de arquivos DEX como 200m. Para obter mais informações, consulte Melhorar os tempos de compilação configurando recursos do DEX.
  • Não ative compilação em paralelo: 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 (em um Mac, 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

O Instant Run é um comportamento dos comandos Run e Debug que reduz consideravelmente o tempo entre as atualizações do aplicativo. Mesmo que sua primeira compilação demore mais para ser concluída, o Instant Run envia atualizações subsequentes ao seu aplicativo sem compilar um novo APK. Assim, as alterações se tornam visíveis com muito mais rapidez.

O Android Studio ativa o Instant Run por padrão para projetos compilados usando o Android Plugin para Gradle 2.0.0 ou posterior. É possível aumentar o desempenho da compilação com o Instant Run modificando algumas configurações do projeto. Para obter mais instruções sobre a configuração do projeto para aumentar o desempenho do 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 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 bloco de CompileOptions {} a seguir ao arquivo build.gradle:

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_6
        targetCompatibility JavaVersion.VERSION_1_6
    }
}

Para obter mais informações sobre onde definir compileSdkVersion, 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 web que adicionam segurança e privacidade às conexões com a Internet.

Para permitir a execução do Android Studio atrás de um firewall, defina as configurações de proxy para o IDE do Android Studio. Use a página de configurações Android Studio IDE HTTP Proxy para definir as configurações de proxy HTTP para Android Studio.

Para executar o Android Plugin 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.

Observação: Após a instalação inicial do pacote do Android Studio, ele poderá ser executado com acesso à Internet ou off-line. No entanto, o Android Studio exige uma conexão com a Internet para sincronização do assistente de configuração, acesso a bibliotecas de terceiros, acesso a repositórios remotos, inicialização e sincronização do Gradle e atualizações de versão do Android Studio.

Configurar o proxy do Android Studio

O Android Studio oferece configurações de proxy HTTP para permitir a execução do Android Studio atrás de um firewall ou rede segura. Para definir as configurações de proxy HTTP no Android Studio:

  1. Na barra de menus, clique em File > Settings (em um Mac, clique em Android Studio > Preferences).
  2. No painel à esquerda, clique em Appearance & Behavior > System Settings > HTTP Proxy. É exibida a página HTTP Proxy.
  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 você mesmo todas as configurações. Para obter uma explicação detalhada dessas configurações, consulte Proxy HTTP.
  4. Clique em Apply ou OK para que as alterações entrem em vigor.

Configurações de proxy HTTP para o Android Plugin para Gradle

Para executar o Android Plugin na linha de comando ou em máquinas em que o Android Studio não esteja instalado, defina as configurações de proxy para o Android Plugin 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 as necessidades de 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 obter informações sobre o uso de propriedades do Gradle para configurações de proxy, consulte o Guia do usuário do Gradle.

Observação: Ao usar o Android Studio, as definições da página de configurações Android Studio IDE HTTP Proxy modificam as configurações de proxy HTTP no arquivo gradle.properties.