Versões anteriores do Android Studio

Esta página lista os novos recursos e melhorias de cada versão principal dos lançamentos anteriores do Android Studio. Para ver as novidades da versão mais recente, consulte as notas da versão atuais do Android Studio.

Para conferir as notícias mais recentes sobre as versões, inclusive uma lista das principais correções em cada versão de pré-lançamento, consulte as atualizações da versão. Para ver mais informações sobre as novidades do Plug-in do Android para Gradle, consulte as notas da versão.

Plug-in do Android para Gradle e compatibilidade com o Android Studio

O sistema de build do Android Studio é baseado no Gradle, e o Plug-in do Android para Gradle adiciona vários recursos específicos para a criação de apps Android. A tabela abaixo lista qual versão do Plug-in do Android para Gradle é necessária para cada versão do Android Studio.

Para ver mais informações sobre as novidades do Plug-in do Android para Gradle, acesse as notas da versão.

Android Studio Chipmunk | 2021.2.1

Suporte para criar o app usando o Jetpack Compose

A visualização de animações oferece suporte à animatedVisibility

O Android Studio Chipmunk oferece suporte à API animatedVisibility na visualização de animações. Para usar a visualização de animações com a animatedVisibility, use a versão 1.1.0 ou mais recente do Compose. Para saber mais sobre a visualização de animações, consulte Animações.

Suporte à implantação da visualização de módulos de biblioteca

As visualizações permitem que você confira a IU no Android Studio sem precisar executar o app em um dispositivo físico. No Android Studio Chipmunk, é possível implantar uma @Preview específica dos módulos de biblioteca em um emulador ou dispositivo físico. Para saber mais, consulte Implantar visualização.

Suporte à criação de perfil do app

Detectar instabilidades no Android 12 e versões mais recentes

Para dispositivos que usam o Android 12 ou versões mais recentes, rastros capturados são mostrados na faixa Janky frames no painel Display do CPU Profiler.

Para detectar instabilidades:

1. No emulador ou dispositivo de desenvolvimento, abra o app.

2. No Android Studio, selecione View > Tool Windows > Profiler ou clique em Profile na barra de ferramentas.

   Se a caixa de diálogo Select Deployment Target solicitar, selecione o dispositivo em que o app vai ser implantado para criar o perfil. Se você estiver conectado a um dispositivo por USB, mas ele não estiver na lista, confira se a depuração USB está ativada.

3. Clique em qualquer lugar da linha do tempo da CPU para abrir o CPU Profiler.

4. A faixa Janky frames aparece na guia Display. Por padrão, o CPU Profiler mostra apenas frames instáveis como candidatos para investigação. Em cada frame instável, a parte vermelha destaca a duração do frame que ultrapassa o prazo de renderização.

5. Ao encontrar um frame instável, clique nele. Também é possível pressionar M para ajustar o zoom e focar no frame selecionado. Os eventos relevantes vão ser destacados nas linhas de execução principais: RenderThread e GPU completion.

6. Você também pode conferir todos os frames ou mais detalhes do tempo de renderização alternando as caixas de seleção All Frames e Lifecycle, respectivamente.

Para ver mais informações, consulte Detecção de instabilidade da IU.

Versões de patch

Confira a lista de versões de patch no Android Studio Chipmunk.

Android Studio Chipmunk | 2021.2.1 Patch 2 (agosto de 2022)

Esta atualização secundária inclui estas correções de bugs e atualizações:

Suporte à Plataforma Android

Com o Android Studio Chipmunk Patch 2 e o Android Gradle 7.2.2, é possível compilar com APIs do Android 13 configurando compileSdk=33. A versão do SDK mínima com suporte é a 32. Não há suporte para minSdk = 33 até o Plug-in do Android para Gradle versão 7.3.0-beta05.

Android Studio Chipmunk | 2021.2.1 Patch 1 (maio de 2022)

Esta atualização secundária inclui estas correções de bugs:

Android Studio Bumblebee | 2021.1.1

O Android Studio Bumblebee é uma versão principal que inclui os recursos e melhorias a seguir.

Visualização interativa do Compose ativada por padrão

A partir do Android Studio Bumblebee, o recurso de visualização interativa é ativado por padrão. A visualização interativa permite que você interaja com uma prévia da mesma forma que em um dispositivo. Ela é isolada de outras visualizações em um ambiente sandbox, em que é possível clicar em elementos e inserir a entrada do usuário na prévia. É uma forma rápida de testar diferentes estados e gestos do elemento que pode ser composto, como uma caixa de seleção marcada ou vazia.

A visualização do modo interativo é executada diretamente no Android Studio, sem a execução de um emulador, o que causa algumas limitações:

• Falta de acesso à rede
• Falta de acesso ao arquivo
• Algumas APIs de contexto podem não estar totalmente disponíveis

Visualização do drawable vetorial animado (AVD)

A ferramenta de drawable vetorial animado oferece a capacidade de visualizar recursos drawable animados. Ela ajuda a visualizar recursos <animation-list>, <animated-vector> e <animated-selector> no Android Studio e facilita a otimização de animações personalizadas.

Atualização do seletor de dispositivos para ferramentas de design

A fim de simplificar a criação de apps para vários tipos de dispositivos Android, atualizamos o seletor de dispositivos em várias janelas de ferramentas de design, como o Layout Editor e a Validação de layout, com dispositivos de referência que refletem os tamanhos mais comuns de cada um. Agora é mais fácil visualizar, validar ou editar o layout em tamanhos de tela que melhor representam os dispositivos mais usados, como smartphones, tables, Android Wear e Android TV.

Execução de testes KMP

Você pode executar testes de projetos Kotlin Multiplatform (KMP) no Android Studio Bumblebee.

Para garantir que seus testes sejam executados corretamente no Android Studio, você precisa atender todos os requisitos abaixo:

• AGP 7.0.0-alpha08 ou mais recente
• Gradle 6.8.2 ou mais recente
• Plug-in do Kotlin 1.4.30 ou mais recente

Classes R não transitivas ativadas por padrão

As classes R não transitivas agora estão ativadas por padrão. Você pode usar classes R não transitivas com o Plug-in do Android para Gradle para criar builds mais rápidos de aplicativos com vários módulos. Isso ajuda a evitar a duplicação de recursos, garantindo que a classe R de cada módulo contenha apenas referências aos próprios recursos, sem extrair referências das dependências. O resultado disso é que os builds ficam mais atualizados e você evita a recompilação.

Para receber ajuda com esse recurso, acesse Refactor > Migrate to Non-Transitive R Classes…

Atualização de suporte para Apple Silicon

Para quem usa o macOS no hardware Apple Silicon (arm64), o Android Studio Arctic Fox e o Android Emulator oferecem suporte a essa nova arquitetura desde o ano passado. No entanto, com essa versão, atualizamos as ferramentas da plataforma do SDK do Android v32.0.0 (que inclui adb e fastboot) e as ferramentas de build v32.1.0 (que inclui o aapt) para se tornarem binários universais. Assim, o tradutor binário Rosetta não é mais necessário na execução das ferramentas para desenvolvedores Android. Veja as notas da versão das ferramentas da plataforma do SDK.

Novidades no Layout Inspector

Registrar snapshots da hierarquia de layout

O Layout Inspector agora permite que você salve snapshots da hierarquia de layout do app em execução para os compartilhar facilmente com outras pessoas ou consultar mais tarde.

Os snapshots capturam os dados que você normalmente veria ao usar o Layout Inspector, incluindo uma renderização 3D detalhada do layout, a árvore de componentes do layout da visualização, do Compose ou híbrido, além de atributos detalhados para cada componente da IU. Para salvar um snapshot, siga estas etapas:

1. Implante o app em um dispositivo com a API de nível 23 ou mais recente.
2. Abra o Layout Inspector selecionando View > Tool Windows > Layout Inspector.
3. O Layout Inspector vai se conectar automaticamente ao processo do app. Se isso não acontecer, selecione o processo do app no menu suspenso.
4. Quando quiser capturar um snapshot, clique em Export snapshot na barra de ferramentas do Layout Inspector.
5. Na caixa de diálogo do sistema, especifique o nome e o local em que você quer salvar o snapshot. Salve o arquivo com uma extensão *.li.

Em seguida, você pode carregar um snapshot do Layout Inspector selecionando File > Open na barra de menus principal e abrindo um arquivo *.li.

Suporte à inspeção da semântica do Compose

No Compose, a Semântica descreve a IU de uma maneira alternativa e compreensível para serviços de acessibilidade e frameworks de testes. No Android Studio Bumblebee, agora é possível usar o Layout Inspector para inspecionar informações semânticas nos layouts do Compose.

Ao selecionar um nó do Compose, use a janela Attributes a fim de verificar se ela declara informações semânticas diretamente, mescla a semântica dos filhos ou ambos. Para identificar rapidamente quais nós incluem semântica, declarada ou mesclada, use o menu suspenso View options na janela Component Tree e selecione Highlight Semantics Layers. Isso destaca apenas os nós da árvore que incluem semântica, e você pode usar o teclado para navegar rapidamente entre eles.

Evitar reinicializações de atividades

Conectar o Layout Inspector a um app em execução em versões mais antigas do Android Studio fazia com que a atividade do app fosse reiniciada. Isso é necessário para definir uma sinalização de dispositivo que permita a inspeção dos layouts do app.

No Android Studio Bumblebee, é possível evitar reinicializações de atividades ao conectar o Layout Inspector definindo essa sinalização antecipadamente usando uma das opções abaixo e seguindo as etapas descritas:

• Ativar uma opção de configuração de execução

  1. Selecione Run > Edit Configurations na barra de menus principal. A caixa de diálogo Run/Debug Configurations aparece.
  2. Navegue até a configuração de execução que você quer usar.
  3. Na seção Layout Inspector options, marque a caixa ao lado de Connect to Layout Inspector without restarting activity.
  4. Use a configuração de execução na próxima vez que quiser inspecionar o app usando o Layout Inspector.

• Definir a sinalização na linha de comando:

  1. Abra uma janela do terminal na máquina conectada ao dispositivo.
  2. Defina a sinalização do dispositivo para o app usando este comando:

  adb shell settings put global debug_view_attributes_application_package <my_package_name>
  

  1. Implante o app no dispositivo e conecte o Layout Inspector. O Android Studio vai verificar se a sinalização está definida e evita reiniciar a atividade, se possível.

Snapshots do Layout Inspector de documentos

Agora é possível capturar snapshots da hierarquia de layouts do app para salvar, compartilhar ou inspecionar mais tarde. Os snapshots capturam os dados que você normalmente veria ao usar o Layout Inspector, incluindo uma renderização 3D detalhada do layout, a árvore de componentes do layout de visualização, do Compose ou híbrido, bem como atributos detalhados para cada componente da IU. Ao inspecionar o layout de um app em execução, clique em Export snapshot na barra de ferramentas do Layout Inspector e salve o snapshot com uma extensão *.li. Em seguida, carregue um snapshot do Layout Inspector selecionando File > Open na barra de menus principal e abrindo um arquivo *.li. O snapshot aparece em uma guia na janela "Editor" para facilitar a comparação com o app em execução.

Novidades de App Inspection

No Android Studio Bumblebee, há novas ferramentas e funcionalidades na janela App Inspection. Abra o App Inspector selecionando View > Tool Windows > App Inspection na barra de menus principal.

Inspetor de rede

O Network Profiler na janela de ferramentas Profilers foi movido para a janela App Inspection. Se você já usou o Network Profiler, todos os mesmos recursos e dados de tráfego de rede avançados ainda estão disponíveis. Basta implantar o app em um dispositivo com a API de nível 26 ou mais recente e abrir a guia App Inspector > Network Inspector.

Inspecionar jobs, alarmes e wake locks

O Inspetor de tarefas em segundo plano agora permite inspecionar os jobs, os alarmes e os wake locks do app, além do suporte existente para a inspeção de workers. Os tipos de tarefa assíncrona agora aparecem no título adequado na guia do inspetor, permitindo monitorar facilmente o status e o progresso de cada um. Assim como os workers, é possível selecionar um job, um alarme ou um wake lock para inspecionar as informações detalhadas no painel Task Details.

Como os workers usam jobs e wake locks em segundo plano, essas tarefas programadas por workers aparecem como filhas de cada worker. Lembre-se de que você só pode ver workers no Graph mode (modo de gráfico).

Depuração por Wi-Fi

O Android Studio Bumblebee oferece suporte ao recurso de depuração por WI-Fi em dispositivos com o Android 11 e versões mais recentes. Pareie e implante o app pelo Android Studio usando o Wi-Fi, sem ter que usar um cabo USB ou gerenciar conexões do Android Debug Bridge (adb) pela linha de comando. Para isso, navegue até a opção Pair devices using Wi-Fi no menu de seleção de dispositivos e selecione usar um código QR ou um código PIN de pareamento. Em seguida, no dispositivo Android 11 ou versões mais recentes, em Opções do desenvolvedor, localize a tela Depuração por Wi-Fi e inicialize e se conecte a uma sessão do adb sem fio com o Android Studio. Saiba mais sobre a configuração de depuração por Wi-Fi em Conectar-se a um dispositivo por Wi-Fi (Android 11 ou mais recente).

Executor de testes unificado do Gradle

O Plug-in do Android para Gradle 7.1.0 e o Android Studio Bumblebee e versões mais recentes usam a implementação própria do Gradle no executor de testes instrumentados Android para realizar esse tipo de teste. Com o mesmo executor de testes, os resultados têm mais probabilidade de serem consistentes, independentemente de você usar o AGP na linha de comando, como em um servidor de integração contínua, ou no Android Studio.

As versões anteriores do Android Studio usam o executor de testes instrumentados Android do IntelliJ em vez do executor de testes instrumentados Android do Gradle. Portanto, se você não estiver usando a versão mais recente do Android Studio, dependendo da execução dos testes no Android Studio ou na linha de comando com o plug-in Gradle, talvez veja resultados de teste diferentes, como testes sendo aprovados com um executor e falhando com outro.

Se você já salvou configurações de testes instrumentados no projeto, elas vão usar o Gradle para executar testes no dispositivo conectado. É possível criar uma nova configuração de testes de instrumentação usando a ação de gutter ao lado da classe ou do método de teste, conforme mostrado abaixo.

Ao executar seus testes de instrumentação, você pode confirmar se o Android Studio está usando o executor de testes do Gradle com a inspeção da saída do teste na Test Matrix para a saída de tarefas do Gradle. Embora melhoremos esse recurso a cada versão do Android Studio, há alguns problemas conhecidos. Se você tiver problemas, informe um bug. Também é possível desativar o novo pipeline de teste para reverter ao comportamento antigo.

Por padrão, o Android Emulator agora é executado diretamente no Android Studio

O Android Emulator passou a ser executado diretamente no Android Studio por padrão. Isso permite economizar espaço na tela, navegar rapidamente entre o emulador e a janela do editor usando teclas de atalho e organizar o fluxo de trabalho do ambiente de desenvolvimento integrado e do emulador em uma única janela do aplicativo.

Quando o emulador estiver em execução, você vai ter acesso a ações comuns dele, como a rotação, e opções de controle estendidas, como a reprodução de navegação. Para executar o emulador em uma janela separada, acesse File > Settings > Tools > Emulator (Android Studio > Preferences > Tools > Emulator no macOS) e desmarque a opção Launch in a tool window.

Desativar o novo pipeline de teste

Por padrão, o Android Studio Bumblebee usa o Gradle para executar testes de instrumentação. Se você tiver algum problema, desative esse comportamento da seguinte maneira:

1. Selecione File > Settings > Build, Execution, Deployment > Testing (ou Android Studio > Preferences > Build, Execution, Deployment > Testing no MacOS).
2. Desmarque a caixa ao lado de Run Android instrumented tests using Gradle e clique em OK.

Também é possível reverter para comportamentos mais antigos seguindo um destes procedimentos:

• Ao executar tarefas do Gradle na linha de comando, use o seguinte parâmetro de linha de comando: -Pandroid.experimental.androidTest.useUnifiedTestPlatform=false
• Adicione este parâmetro ao arquivo gradle.properties do projeto: android.experimental.androidTest.useUnifiedTestPlatform=false

Para receber ajuda com a resolução de problemas, informe um bug.

Novo Gerenciador de dispositivos

O Gerenciador de dispositivos é uma substituição independente para o AVD Manager, tanto da tela de boas-vindas do Android Studio quanto de um projeto aberto. O Gerenciador de dispositivos apresenta alguns recursos novos que facilitam a criação e o gerenciamento de todos os dispositivos de teste locais, por exemplo:

• Uma IU mais flexível e com suporte para a base no ambiente de desenvolvimento integrado, flutuante ou em uma janela separada, como é possível fazer com outras janelas de ferramentas do Android Studio. Isso facilita o acesso aos dispositivos sem obstruir outras janelas do ambiente de desenvolvimento integrado;
• Uma guia Virtual que permite criar, gerenciar e implantar dispositivos virtuais, ver resumos de detalhes de cada dispositivo ou inspecionar rapidamente o dispositivo no Device File Explorer com um único clique;
• Uma guia Physical que permite parear rapidamente um novo dispositivo usando o ADB Wi-Fi e ver um resumo dos detalhes de cada dispositivo físico. Você também pode inspecionar rapidamente o sistema de arquivos de cada dispositivo usando o Device File Explorer com apenas um clique.

Para abrir o novo Gerenciador de dispositivos, siga um destes procedimentos:

• Na tela de boas-vindas do Android Studio, selecione More Actions > Virtual Device Manager.

• Depois de abrir um projeto, selecione View > Tool Windows > Device Manager na barra de menus principal.

Detecção de instabilidade da IU

Ao criar um perfil do app usando dispositivos com o Android 11 (API de nível 30) ou versões mais recentes, o CPU Profiler agora mostra um novo grupo de faixas que ilustram os estágios de cada frame em Frame Lifecycle: Application, Wait for GPU, Composition e Frames on display. As faixas identificam cada frame com um número e codificam os retângulos com cores. Isso facilita a visualização do local em que um frame específico está no ciclo de vida, bem como dos guias que podem ser usados para comparar eventos de Vsync. É possível usar esses dados para entender onde pode haver instabilidade no app e investigar as causas. No painel Analysis, agora há uma guia Frames, que resume as informações de renderização de todos os frames. Para ver mais informações, consulte Detecção de instabilidade da IU.

Suporte para a criação de perfil em um app

Ao criar um perfil do app, é importante gerar dados precisos com a versão do app mais parecida com a que vai ser instalada pelos usuários. Para fazer isso, agora você pode incluir a propriedade <profileable> no manifesto do app a fim de gerar perfis para apps que não são depuráveis, conforme mostrado no código a seguir.

<profileable android:shell="true"/>

Profileable é uma configuração de manifesto que foi lançada no Android 10 e está disponível para tarefas de geração de perfil de CPU e memória. A principal vantagem de usar a flag "profileable", em vez da "debuggable", é a redução da sobrecarga ao medir a performance. No entanto, alguns recursos de criação de perfil não estão disponíveis para builds da profileable, como linha do tempo de eventos, criação de perfil de CPU iniciada pela API, heap dumps ou gravações de localização em tempo real. Para ver mais informações, consulte Aplicativos com perfil.

Recolher frames da pilha de chamadas

Agora, é possível recolher os frames que não são relevantes para sua investigação ao inspecionar um Callstack Sample Recording na janela de ferramentas Profilers. As pilhas de chamadas são úteis para entender qual parte do código foi executada e por que ela foi invocada. No entanto, a pilha de chamadas para um programa Java ou Kotlin geralmente não apenas inclui o código Java ou Kotlin, como também os frames do código nativo, que podem dificultar a visualização. Para saber mais sobre como refinar a visualização da pilha de chamadas, consulte Inspecionar frames da pilha de chamadas.

Versões de patch

Esta é uma lista das versões de patch do Android Studio Bumblebee.

Android Studio Bumblebee | 2021.1.1 Patch 3 (abril de 2022)

Esta atualização secundária inclui estas correções de bugs:

• Plug-in do Android para Gradle
  • Os problemas de classes duplicadas foram relatados pelo R8
• Variantes de build
  • versionNameSuffix não funciona mais quando o nome da versão da variante é definido pela nova API onVariants.
• Visualização do Compose
  • Correções de bugs relacionadas a performance e estabilidade.
  • Corrigidos os congelamentos que ocorriam ocasionalmente ao usar o recurso de edição ao vivo de literais.
• Inspetor de rede
  • O novo inspetor de rede falha após a atualização do Bumblebee
  • O erro aparece constantemente quando o depurador está conectado à versão mais recente do Android Studio.
  • TrackedHttpURLConnection.getHeaderField falha com NullPointerException.

Android Studio Bumblebee | 2021.1.1 Patch 2 (fevereiro de 2022)

Esta atualização inclui as seguintes correções de bugs:

• Build em C++
  • ModelCache.safeGet(androidProjectResult.androidProject::getNdkVersion, "") não pode ser nulo.
• Editor de código
  • Bug nos modelos dinâmicos do Android Studio. A expressão className() não resolve o nome da classe.
• D8/R8
  • java.lang.NoSuchMethodError: sem o método estático $jacocoInit.
  • Cobertura do teste do Android corrompida devido a um erro do Mockito.
  • É preciso uma solução alternativa para uma implementação de CAS corrompida no nível 31 da API.
  • Não há suporte para classes seladas.
  • NullPointerException ao ativar a mesclagem de classes horizontais no Chrome.
  • AbstractMethodError após a integração do método virtual.
  • Falha ao verificar os frames de pilha devido a um tipo init-class incorreto.
  • A entrada DEX usa um registro não definido.
  • O StringBuilderOptimizerAnalysisTest falha em ramificações de lançamento.
  • Não determinismo no R8.
• Implantação
  • A execução do projeto de um app do proprietário do dispositivo falha com a mensagem de erro "Não foi possível encerrar o processo existente".
• Ferramentas de design
  • As visualizações do Compose não encontram recursos de outros módulos quando as classes R não transitivas estão ativadas.
  • O Studio trava durante a compilação.
• Emulador incorporado
  • Várias melhorias de performance e estabilidade.
• Importar/Sincronizar
  • Erro do ambiente de desenvolvimento integrado ao iniciar o Bumblebee: o arquivo do build da lista de saída não está disponível para o tipo de APK em IdeBuildTasksAndOutputInformationImp.
• IntelliJ
  • Variáveis de ambiente sem origem quando iniciadas no Mac OS X Monterey Dock
• Jetpack (androidx) > Navegação
  • Upgrade do SafeArgs para que possa ser criado no AGP estável mais recente.
• Janelas de ferramentas
  • Não é possível executar o Gerenciador de dispositivos Android.
  • O Network Inspector no BumbleBee não mostra a resposta da API em um formato legível.

Android Studio Bumblebee | 2021.1.1 Patch 1 (fevereiro de 2022)

Esta atualização secundária inclui estas correções de bugs:

• Emulador
  • Falha ao se conectar ao emulador incorporado após fazer upgrade para o Bumblebee (Mac M1)
• IntelliJ
  • Variáveis de ambiente sem origem quando iniciadas no Mac OS X Monterey Dock

Para ver mais informações, consulte a postagem do blog Android Studio Bumblebee Patch 1 (link em inglês).

Android Studio Arctic Fox | 2020.3.1

O Android Studio Arctic Fox é uma versão principal que inclui os recursos e melhorias a seguir.

Numeração da nova versão

Atualização do número da versão do Android Studio

Mudamos o sistema de numeração de versões do Android Studio para deixá-lo mais alinhado com o IntelliJ IDEA (link em inglês), o ambiente de desenvolvimento integrado em que o Android Studio se baseia.

No sistema de numeração anterior, essa versão teria sido numerada como Android Studio 4.3 ou versão 4.3.0.1. Com o novo sistema de numeração, ela passa a ser Android Studio - Arctic Fox | 2020.3.1 ou a versão 2020.3.1.

Veja como o número da versão do Android Studio será determinado a partir de agora:

<Year of IntelliJ Version>.<IntelliJ major version>.<Studio major version>.<Studio minor/patch version>

• Os dois primeiros grupos de números representam a versão da plataforma IntelliJ em que determinada versão do Android Studio é baseada. Aqui, a versão é a 2020.3.
• O terceiro grupo de números representa a versão principal do Studio, começando em 1 e aumentando um número para cada versão principal subsequente.
• O quarto grupo de números representa a versão secundária/de patch do Studio, começando em 1 e aumentando um número a cada versão secundária.
• Também daremos, para cada versão principal, um nome baseado em nomes de animais e com iniciais em ordem alfabética de A a Z. O nome desta versão é Arctic Fox (raposa-do-ártico, em inglês).

Atualização do número da versão do Plug-in do Android para Gradle

Mudamos o número da versão do Plug-in do Android para Gradle (AGP, na sigla em inglês) a fim de melhorar a integração com a ferramenta de build do Gradle. Portanto, o AGP 7.0 será a próxima versão após o AGP 4.2.

Para ver mais detalhes, consulte as Mudanças do controle de versões nas notas da versão do AGP.

Plug-in do Android para Gradle 7.0.0

A versão mais recente do Plug-in do Android para Gradle inclui muitas atualizações. Para saber mais, leia as notas da versão completas do Plug-in do Android para Gradle.

Os testes de unidade agora usam o executor de testes do Gradle

Para melhorar a consistência geral das execuções de teste, o Android Studio agora usa o Gradle para executar todos os testes de unidade por padrão. Em muitos casos, essa mudança não afetará seu fluxo de trabalho de testes no ambiente de desenvolvimento integrado.

Por exemplo, quando você clica no comando Run no menu de contexto (visível ao clicar com o botão direito do mouse em uma classe de teste) ou na ação de gutter correspondente , por padrão, o Android Studio usa a configuração de execução do Gradle para executar os testes de unidade.

No entanto, o Android Studio não reconhece mais as configurações de execução do Android JUnit. Por isso, você precisa migrar as configurações de execução do Android JUnit que podem ser salvas como arquivos de projeto para configurações de execução do Gradle.

Para criar uma configuração de teste do Gradle, selecione o modelo para Gradle seguindo as instruções em Criar uma nova configuração de execução/depuração. Quando você cria uma nova configuração, ela aparece na caixa de diálogo Edit Configurations, na seção "Gradle":

Se quiser inspecionar as configurações do Android JUnit que não são mais reconhecidas, você tem duas opções:

• Abra as configurações salvas manualmente em um editor de texto. Os locais desses arquivos são especificados pelo usuário, mas eles costumam estar em <my-app>/.idea/runConfigurations/.

• Procure configurações temporárias em <my-app>/.idea/workspace.xml e procure no nó <component name="RunManager" ...>. Exemplo:

  <component name="RunManager" selected="Gradle.PlantTest">
  …
  <configuration name="PlantTest" type="AndroidJUnit" factoryName="Android JUnit" nameIsGenerated="true">
        <module name="Sunflower.app" />
        <useClassPathOnly />
        <extension name="coverage">
          <pattern>
            <option name="PATTERN" value="com.google.samples.apps.sunflower.data.*" />
            <option name="ENABLED" value="true" />
          </pattern>
        </extension>
        <option name="PACKAGE_NAME" value="com.google.samples.apps.sunflower.data" />
        <option name="MAIN_CLASS_NAME" value="com.google.samples.apps.sunflower.data.PlantTest" />
        <option name="METHOD_NAME" value="" />
        <option name="TEST_OBJECT" value="class" />
        <option name="PARAMETERS" value="" />
        <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
        <method v="2">
          <option name="Android.Gradle.BeforeRunTask" enabled="true" />
        </method>
      </configuration>
  

Novo Inspetor de tarefas em segundo plano

Você pode visualizar, monitorar e depurar os workers em segundo plano do seu app usando o novo Inspetor de tarefas em segundo plano. Para começar, implante o app em um dispositivo com a Biblioteca do WorkManager 2.5.0 ou mais recente e selecione View > Tool Windows > App Inspection na barra de menus.

Para ver informações mais detalhadas, clique em um worker. Por exemplo, é possível ver a descrição dele, como ele foi executado, os detalhes da cadeia de workers e o resultado da execução.

Você também pode ver uma representação visual de uma cadeia de workers. Para isso, selecione um worker na tabela e clique em Show Graph View na barra de ferramentas. Em seguida, você pode selecionar qualquer worker na cadeia para ver os detalhes dele ou, caso ele esteja na fila ou em execução no momento, interrompê-lo. Para retornar à tabela, clique em Show List View .

Para ajudar a investigar problemas de workers que falham durante a execução, você pode interromper um worker que está em execução ou na fila selecionando-o na tabela e clicando em Cancel Selected Worker na barra de ferramentas. Também é possível filtrar os workers na tabela pelas tags que você atribuiu a eles usando o menu suspenso All tags.

Atualizações do Database Inspector

O Database Inspector agora está incluído na nova janela da ferramenta App Inspection, onde você também pode encontrar o novo Inspetor de tarefas em segundo plano. Abra a janela da ferramenta App Inspection na barra de janelas de ferramentas ou selecione View > Tool Windows > App Inspection na barra de menus.

Exportar dados do Database Inspector

No Arctic Fox, é fácil exportar bancos de dados, tabelas e resultados de consulta do Database Inspector para salvar, compartilhar ou recriar localmente. Ao abrir um projeto de app no Android Studio e inspecionar o app no Database Inspector, você pode começar a exportar dados de uma destas maneiras:

• Selecione um banco de dados ou uma tabela no painel Databases e clique em Export to file próximo à parte de cima do painel.
• Clique com o botão direito do mouse em um banco de dados ou em uma tabela no painel Databases e selecione Export to file no menu de contexto.
• Ao inspecionar uma tabela ou resultados de consulta em uma guia, clique em Export to file acima da tabela ou dos resultados da consulta.

Depois de selecionar uma ação de exportação, use a caixa de diálogo Export para ajudar você nas etapas finais, conforme mostrado abaixo. Se estiver tentando exportar um banco de dados, uma tabela ou resultados de consulta, você terá a opção de exportar os dados em um ou mais dos seguintes formatos: DB, SQL ou CSV.

Atualização na IU para gravação no Memory Profiler

Consolidamos a interface do usuário (IU) do Memory Profiler para diferentes atividades de gravação, como capturar um heap dump e gravar em Java, Kotlin e alocações de memória nativas.

O Memory Profiler oferece as seguintes opções:

• Capture heap dump: veja objetos no seu app que usam a memória em um momento específico.
• Record native allocations: veja como cada objeto C/C++ foi alocado durante um período.
• Record Java/Kotlin allocations: veja como cada objeto Java/Kotlin foi alocado durante um período.

Veja como usar essas três opções:

• Para capturar um heap dump, selecione Capture heap dump e escolha Record. Depois que o criador de perfil termina a captura do heap dump, a IU do Memory Profiler faz a transição para uma tela separada que mostra o heap dump.

  

• Para gravar alocações nativas em dispositivos com Android 10 e versões mais recentes, selecione Record native allocations e Record. A gravação continua até você clicar em Stop . Depois disso, a IU do Memory Profiler faz a transição para uma tela separada que exibe a gravação nativa.

  No Android 9 e versões anteriores, a opção Record native allocations não está disponível.

• Para gravar alocações Java e Kotlin, selecione Record Java / Kotlin allocations e escolha Record. Se o dispositivo está executando o Android 8 ou versões mais recentes, a IU do Memory Profiler faz a transição para uma tela separada que exibe a gravação em andamento. É possível interagir com a mini linha do tempo acima da gravação (por exemplo, para mudar o intervalo de seleção). Para concluir a gravação, selecione Stop .

  

  No Android 7.1 e versões anteriores, o Memory Profiler usa a gravação de alocação legada, que mostra a gravação na linha do tempo até você clicar em Stop.

Atualizações no projeto C++ vinculado

Movemos os arquivos não relacionados à configuração da pasta .cxx/ para a pasta build/. Os builds do CMake C++ exigem uma fase de configuração que gera o projeto Ninja usado para executar as etapas de compilação e vinculação. Os projetos gerados pelo CMake são difíceis de gerar e precisam sobreviver no Gradle limpos. Por isso, eles são armazenados em uma pasta chamada .cxx/, ao lado da pasta build/. Normalmente, o Plug-in do Android para Gradle observa mudanças na configuração e gera automaticamente o projeto Ninja de novo. No entanto, nem todos os casos podem ser detectados. Quando isso acontece, a opção "Refresh Linked C++ Project" poder ser usada para gerar um novo projeto Ninja de forma manual.

Nova matriz de teste para vários dispositivos

Agora, os testes de instrumentação podem ser executados em vários dispositivos em paralelo e ser investigados usando um painel de resultados de testes de instrumentação especializado. Usando esse painel, você pode determinar se os testes estão falhando devido ao nível da API ou a propriedades de hardware.

Testar o app em uma ampla variedade de níveis da API e formatos é uma das melhores maneiras de garantir que todos os usuários tenham uma boa experiência ao usá-lo.

Para aproveitar esse recurso:

1. Escolha Select Multiple Devices no menu suspenso de dispositivo de destino, na parte central superior do ambiente de desenvolvimento integrado.

   

2. Selecione os dispositivos de destino e clique em OK.

   

3. Execute seus testes.

Para ver os resultados do teste no painel Run, acesse View > Tool Windows > Run.

O novo painel de resultados do teste permite filtrar os resultados por status, dispositivo e nível da API. Além disso, é possível classificar cada coluna clicando no cabeçalho. Ao clicar em um teste individual, você vê os registros e as informações dele individualmente.

Suporte a StateFlow na vinculação de dados

Para apps Kotlin que usam corrotinas, agora você pode usar objetos StateFlow como uma fonte de vinculação de dados para notificar automaticamente a IU sobre mudanças nos dados. As vinculações de dados vão reconhecer o ciclo de vida e só serão acionadas quando a IU estiver visível na tela.

Para usar um objeto StateFlow com sua classe de vinculação, é preciso especificar um proprietário do ciclo de vida para definir o escopo do objeto StateFlow e, no layout, atribuir as propriedades e os métodos do componente ViewModel às visualizações correspondentes que usam expressões de vinculação, conforme mostrado no exemplo a seguir:

class ViewModel() {
   val username: StateFlow<String>
}

<TextView
    android:id="@+id/name"
    android:text="@{viewmodel.username}" />

Para um app Kotlin que usa o AndroidX, o suporte ao StateFlow vai ser adicionado automaticamente na funcionalidade de vinculação de dados, incluindo as dependências de corrotinas.

Para saber mais, consulte Trabalhar com objetos de dados observáveis.

Melhorias na importação sugerida

Melhoramos o número de bibliotecas que oferecem suporte para o recurso de importação sugerida e atualizamos o índice com mais frequência. A importação sugerida ajuda a importar com rapidez e facilidade determinados artefatos do Google Maven para a classe e o projeto do Gradle. Quando o Android Studio detecta símbolos não resolvidos de determinadas bibliotecas do Google, o ambiente de desenvolvimento integrado sugere a importação da biblioteca para a classe e o projeto.

Suporte a cache de configuração no Build Analyzer

O Build Analyzer identifica quando um projeto não tem o cache de configuração ativado e o oferece como uma otimização. O Build Analyzer executa uma avaliação de compatibilidade para informar se há algum problema com o cache de configuração no projeto antes da ativação dele.

Melhorias no assistente de upgrade para AGP

O Assistente de upgrade do Plug-in do Android para Gradle agora tem uma janela de ferramentas persistente com a lista das etapas que vão ser concluídas. Outras informações também são apresentadas no lado direito da janela de ferramentas. Se necessário, também é possível escolher uma versão diferente do AGP para fazer upgrade. Clicar no botão Refresh atualiza as etapas correspondentes de atualização.

Refatoração para classes R não transitivas

Você pode usar classes R não transitivas com o Plug-in do Android para Gradle para criar builds mais rápidos para aplicativos com vários módulos. Isso ajuda a evitar a duplicação de recursos, garantindo que a classe R de cada módulo contenha apenas referências aos próprios recursos, sem extrair referências das dependências. Isso leva a builds mais atualizados e aos benefícios correspondentes de evitar a compilação.

Acesse esse recurso em Refactor > Migrate to Non-transitive R Classes.

Suporte às ferramentas do Jetpack Compose

Agora oferecemos mais suporte à visualização e ao teste de apps que usam o Jetpack Compose. Para ter a melhor experiência de desenvolvimento com o Jetpack Compose, use a versão mais recente do Android Studio Arctic Fox para aproveitar os recursos do editor inteligente, como modelos para novos projetos e a capacidade de visualizar imediatamente a IU do Compose.

Visualização do Compose

Os seguintes parâmetros para métodos @Preview agora estão disponíveis:

• showBackground: ative e desative um plano de fundo para sua visualização.
• backgroundColor: defina uma cor para ser usada apenas na superfície de visualização.
• uiMode: esse novo parâmetro pode assumir qualquer uma das constantes Configuration.UI_* e possibilita que você mude o comportamento da visualização para, por exemplo, definir o Modo noturno, para ver como o tema reage.

Visualização interativa

Use esse recurso para interagir com os componentes de IU, clicar neles e ver como o estado muda. Essa é uma forma rápida para ver como a IU reage e visualizar as animações. Para ativá-la, basta clicar no ícone interativo , e a visualização alterna entre os modos.

Para interromper, clique em Stop Interactive Preview na barra de ferramentas superior.

Implantar no dispositivo

Use esse recurso para implantar um snippet da sua IU em um dispositivo. Isso ajuda a testar partes pequenas do seu código no dispositivo sem precisar iniciar o aplicativo completo.

Clique no ícone Deploy to Device ao lado da anotação @Preview, ou na parte de cima da visualização, e o Android Studio vai implantar @Preview no dispositivo ou emulador conectado.

Edição em tempo real de literais

Adicionamos a edição em tempo real de literais para ajudar os desenvolvedores que usam o Compose a editar literais (strings, números e booleanos) rapidamente no código e conferir os resultados imediatamente sem precisar esperar pela compilação. O objetivo desse recurso é aumentar sua produtividade fazendo com que as mudanças no código apareçam quase instantaneamente nas visualizações, no emulador ou no dispositivo físico.

Suporte ao Compose no Layout Inspector

O Layout Inspector permite consultar vários detalhes sobre o layout do app em execução no dispositivo conectado. É possível interagir com o app e ver atualizações em tempo real na ferramenta para depurar rapidamente problemas que possam surgir.

Você pode inspecionar layouts criados com o novo framework de IU declarativa do Android, o Jetpack Compose. Independentemente de o app usar layouts totalmente escritos no Compose ou que usam um híbrido de Compose e Views, o Layout Inspector ajuda a entender como os layouts são renderizados no dispositivo em execução.

Começar

Para começar, implante o app em um dispositivo conectado e abra a janela Layout Inspector selecionando View > Tool Windows > Layout Inspector. Se o Layout Inspector não se conectar automaticamente ao processo do app, selecione a opção preferida no menu suspenso. Em breve, o layout do app vai ser renderizado na janela de ferramentas. Para começar a inspecionar o layout do Compose, selecione o componente de layout visível na renderização ou na Component Tree.

A janela Attributes mostra informações detalhadas sobre a função do Compose selecionada no momento. Nessa janela, é possível inspecionar os parâmetros da função e seus valores, incluindo modificadores e expressões lambda. Para expressões lambda, o inspetor fornece um atalho para ajudar você a navegar até a expressão no código-fonte.

O Layout Inspector mostra todas as funções do Compose na pilha de chamadas que emitem componentes para o layout do seu app. Em muitos casos, isso inclui funções do Compose que são chamadas internamente pela biblioteca dele. Se você quiser ver apenas as funções do Compose na Component Tree que o app chama diretamente, clique na ação de filtro , que pode reduzir o número de nós mostrados na árvore aos que você provavelmente quer inspecionar.

Melhorias no menu suspenso de implantação

O menu suspenso do dispositivo agora distingue os diferentes tipos de erros na configuração do dispositivo escolhida. Agora, a iconografia e as mudanças estilísticas diferenciam entre erros, que são seleções de dispositivos que resultam em uma configuração corrompida, e alertas, que são seleções de dispositivos que podem resultar em comportamentos inesperados, mas ainda podem ser executados.

Além disso, agora o Android Studio avisa se você tentar iniciar o projeto em um dispositivo que tenha um erro ou um aviso associado a ele.

Novo assistente de pareamento do Wear OS

O novo assistente de pareamento do Wear OS guia os desenvolvedores em cada etapa ao parear emuladores do Wear OS com smartphones físicos ou virtuais diretamente no Android Studio. O assistente ajuda a instalar o app complementar correto do Wear OS no smartphone e configurar uma conexão entre os dois dispositivos. Para começar, acesse o menu suspenso do dispositivo > Wear OS Emulator Pairing Assistant.

Modelo de layout responsivo

O Android Studio Arctic Fox agora inclui um novo modelo de layout que se adapta a várias dimensões de tela e redimensionamento de apps, como em smartphones, dispositivos dobráveis, tablets e modos de tela dividida. Ao criar um novo projeto ou módulo, selecione o modelo "Responsive Activity" para criar um layout com componentes que são redimensionados dinamicamente.

Para começar, acesse File > New, selecione New Project ou New Module e escolha o modelo Responsive Activity.

Problemas conhecidos do Arctic Fox

Esta seção descreve os problemas conhecidos atuais do Android Studio Arctic Fox.

Os patches não funcionam no Windows para a v3.6-v4.1

Os patches na plataforma Windows para a v3.6-v4.1 do Android Studio Arctic Fox estável podem não funcionar.

4.2 (abril de 2021)

O Android Studio 4.2 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

Plug-in do Android para Gradle 4.2.0

A versão mais recente do Plug-in do Android para Gradle inclui muitas atualizações. Para saber mais, leia as notas da versão completas do Plug-in do Android para Gradle.

Mudanças na configuração e compatibilidade do Gradle

Quando a ferramenta de build do Gradle é executada no Android Studio, ela usa o JDK empacotado no Studio. Em versões anteriores, o JDK 8 era incluído no Studio. No entanto, na versão 4.2, o JDK 11 agora é incluído. Ao usar o novo JDK incluído para executar o Gradle, isso pode resultar em alguma incompatibilidade ou afetar o desempenho do JVM devido a alterações no coletor de lixo. Esses problemas estão descritos nas notas da versão do AGP.

Opção para otimizar o tempo de sincronização do Gradle

Para melhorar a performance de sincronização do Gradle, o Android Studio ignora a criação da lista de tarefas durante a sincronização. Isso permite que a sincronização do Gradle seja concluída mais rapidamente e melhora a capacidade de resposta da IU em projetos muito grandes. Essa opção é ativada por padrão no Android Studio 4.2. Para desativá-la, acesse File > Settings > Experimental (no Mac, Preferences > Experimental) e desmarque a opção Do not build Gradle task list during Gradle sync.

Database Inspector

Melhorias no Editor de consultas

O Database Inspector inclui algumas melhorias para ajudar você a criar e executar suas instruções SQL personalizadas. Ao abrir o inspetor e depois uma guia New query, você vê uma superfície de editor redimensionável maior para criar e formatar suas consultas, conforme mostrado abaixo.

Além disso, agora fornecemos um histórico de suas consultas anteriores. Ao clicar no botão Show query history , você vê uma lista das consultas executadas anteriormente no banco de dados selecionado. Clique em uma consulta na lista para uma visualização de toda a consulta no editor e pressione Enter para copiá-la no editor. Em seguida, clique em Run para executar a instrução.

Modo off-line

Nas versões anteriores do Android Studio, desconectar-se de um processo de app ao usar o Database Inspector resultava no fechamento do inspetor e dos dados. No Android Studio 4.2, adicionamos a possibilidade de continuar inspecionando os bancos de dados do app após a desconexão de um processo, facilitando a depuração do app após uma falha.

Quando ocorre uma desconexão, o Database Inspector faz o download dos seus bancos de dados e os disponibiliza no modo off-line. Quando estiver off-line, será possível abrir tabelas e executar consultas.

Lembre-se de que, quando você se reconecta a um processo de app ativo, o Database Inspector retorna ao modo ativo e mostra apenas os dados que estão no dispositivo. Ou seja, os dados mostrados no modo off-line não são mantidos quando você se reconecta a um processo de app. Por isso, o Database Inspector não permite a edição ou a execução de instruções de modificação no modo off-line.

Assistente de upgrade para AGP

Um novo assistente de upgrade para o Plug-in do Android para Gradle pode ajudar a atualizar a versão do AGP do seu projeto.

Criado sobre a funcionalidade de upgrade do AGP atual, essa ferramenta orienta você sobre atualizações/refatorações de todo o projeto e inclui uma visualização das atualizações para ajudar a evitar possíveis alterações interruptivas antes de executar o upgrade do AGP.

Rastreamento do sistema: melhorias nas métricas para memória e gráficos

No CPU Profiler, o recurso System Trace agora inclui novas métricas para analisar a performance do app, além do seguinte:

• Tabela de eventos. Lista todos os eventos de rastreamento na linha de execução selecionada.

• BufferQueue. Na seção "Display", essa nova faixa mostra a contagem de buffers da superfície BufferQueue (0, 1 ou 2) do app. Isso ajuda você a entender o estado dos buffers de imagem conforme eles se movem entre os componentes gráficos do Android.

  

• Frequência da CPU. Na seção "CPU cores", essa nova faixa exibe a frequência da CPU por núcleo, indicando a dificuldade de cada núcleo.

  

• Process Memory (RSS). Essa nova janela mostra a quantidade de memória física atualmente em uso pelo app.

  

Para mais detalhes, consulte Inspecionar atividades de CPU com o CPU Profiler.

Nova ação de atualização do Layout Inspector

Introduzido no Android Studio 4.0, o Layout Inspector foi projetado para inspeção em tempo real da pilha de IU do app em execução. No entanto, nem sempre você quer que o Layout Inspector reflita imediatamente o que está acontecendo no seu app, porque pode ser útil inspecionar um instantâneo do layout do app em um momento específico ou minimizar o impacto do desempenho das atualizações em tempo real no seu app.

Pausar atualizações em tempo real e atualizar a captura de tela no Layout Inspector.

Para carregar manualmente um instantâneo dos dados da IU do app, primeiro desative a opção Live Updates. Depois, clique no botão Refresh para capturar um novo instantâneo da pilha de IU para inspeção. O Layout Inspector agora lembra sua preferência para manter a opção Live Updates ativada ou desativada entre as sessões.

Compatibilidade com o Safe Args

Safe Args é um plug-in do Gradle que gera classes simples de objeto e criação para navegação segura e acesso a quaisquer argumentos associados. O Android Studio agora inclui compatibilidade mais abrangente com o Safe Args, conforme descrito abaixo:

• preenchimentos automáticos para Directions, Args e as várias classes de criação;
• suporte a plug-ins safe args do Java e Kotlin;
• navegação da origem para XML.

Retrace do R8 agora disponível nas ferramentas de linha de comando

Disponível na versão 4.0 das ferramentas de linha de comando, o retrace do R8 é uma ferramenta separada que permite usar um stack trace ofuscado para conseguir o original.

É possível fazer o download desse pacote com o SDK Manager, que instala o retrace do R8 em android_sdk/cmdline-tools. Como alternativa, faça o download do pacote de ferramentas de linha de comando autônoma.

Para informações de uso, consulte Retrace do R8 no guia do usuário.

Implantar em vários dispositivos

Para ajudar a simplificar o teste de apps em dispositivos e níveis de API diferentes, agora você pode implantar o app em vários dispositivos ou emuladores simultaneamente seguindo estas etapas:

1. Escolha Select Multiple Devices no menu suspenso de dispositivo de destino (na parte central superior do ambiente de desenvolvimento integrado).

   

2. Selecione os dispositivos de destino e clique em OK.

   

3. Execute o app.

Nova configuração removable para módulos de recursos

O Plug-in do Android para Gradle 4.2 usa o bundletool 1.0.0, que apresenta uma mudança de comportamento para apps que usam módulos de recursos: qualquer módulo de recurso especificado como dist:install-time que não esteja explicitamente marcado como dist:removable se torna não removível por padrão. Essa nova configuração otimiza a fusão de módulos de tempo de instalação com o módulo base, potencialmente melhorando o desempenho do app em alguns apps.

Para manter os módulos de recursos removíveis, defina dist:removable="true" em qualquer módulo que você queira desinstalar.

Para mais informações sobre essa nova configuração, consulte a documentação da tag dist:removable na documentação do manifesto do módulo de recursos.

Apply Changes

Para aumentar a produtividade durante a iteração no seu app, fizemos as seguintes melhorias em "Apply Changes" para dispositivos que executam o Android 11 ou mais recente:

Suporte a outras mudanças de código

Para dispositivos com Android 11 ou versões mais recentes, agora é possível adicionar campos primitivos finais estáticos e implantar essas mudanças no app em execução, clicando em Apply Code Changes ou Apply Changes and Restart Activity .

Agora você também pode adicionar recursos e implantar essas mudanças no seu app em execução nos dispositivos Android 11 clicando em Apply Changes and Restart Activity .

Assistentes atualizados de New Project e New Module

Os assistentes de New Project e New Module foram atualizados para facilitar a navegação, selecionar um modelo e inserir informações sobre o novo projeto ou módulo.

A opção Import .JAR/.AAR Package do assistente New Module também foi removida. Para importar um JAR ou AAR para seu projeto, use a caixa de diálogo "Project Structure".

Kotlin 1.4.31

O Android Studio 4.2 inclui o Kotlin 1.4.31. Consulte o registro de alterações do Kotlin 1.4.0 para analisar as principais mudanças.

O uso da variável de ambiente ANDROID_SDK_HOME foi descontinuado

O uso da variável de ambiente ANDROID_SDK_HOME foi descontinuado e ela foi substituída por ANDROID_PREFS_ROOT. Para ver mais informações, consulte Variáveis de ambiente do emulador.

Problemas conhecidos com o Android Studio 4.2

Esta seção descreve problemas conhecidos que existem no Android Studio 4.2. Para ver uma lista completa, acesse a página Problemas conhecidos.

O Android Studio 4.2.0 gera projetos com a versão incorreta do Kotlin: "1.5.0-release-764"

Se você estiver usando o Android Studio 4.2.0 após atualizar para a versão 1.5.0 do plug-in do Kotlin, vai ocorrer um problema na criação dos novos projetos Kotlin feitos no Studio, devido ao seguinte erro de sincronização do Gradle: Could not find org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.0-release-764.

Como solução, substitua "1.5.0-release-764" por "1.5.0" nos arquivos build.gradle do projeto.

Erro ao usar senhas diferentes para a chave e o keystore

A partir da versão 4.2, o Android Studio é executado no JDK 11. Essa atualização causa uma mudança de comportamento subjacente relacionada às chaves de assinatura.

Ao acessar Build > Generate Signed Bundle / APK e tentar configurar a assinatura de apps para um pacote de apps ou um APK, a inserção de senhas diferentes para a chave e o keystore pode resultar no seguinte erro:

Key was created with errors:
Warning: Different store and Key passwords not supported for PKCS12 Key stores

Para contornar esse problema, insira a mesma senha para a chave e o keystore.

O Android Studio não inicia após a instalação da versão 4.2

O Studio tenta importar .vmoptions anteriores e limpá-los para serem compatíveis com o coletor de lixo usado pelo JDK 11. Se esse processo falha, o ambiente de desenvolvimento integrado talvez não inicie para determinados usuários que definiram opções de VM personalizadas no arquivo .vmoptions.

Para contornar esse problema, recomendamos que você comente opções personalizadas em .vmoptions (usando o caractere "#"). O arquivo .vmoptions pode ser encontrado nos seguintes locais:

Windows

C:\Users\YourUserName\AppData\[Local|Roaming]\Google\AndroidStudio4.2\studio64.exe.vmoptions

macOS

~/Library/Application Support/Google/AndroidStudio4.2/studio.vmoptions

Linux

~/.config/Google/AndroidStudio4.2/studio64.vmoptions

Se o Studio ainda não é iniciado depois dessa solução alternativa, consulte O Studio não inicia após o upgrade abaixo.

4.1 (Agosto de 2020)

O Android Studio 4.1. é uma versão principal que inclui vários novos recursos e melhorias.

Plug-in do Android para Gradle 4.1.0

A versão mais recente do Plug-in do Android para Gradle inclui muitas atualizações. Para saber mais, leia as notas da versão completas do Plug-in do Android para Gradle.

Novo Database Inspector

Inspecione, consulte e modifique os bancos de dados no seu app em execução usando o novo Database Inspector. Para começar, implante o app em um dispositivo que execute a API de nível 26 ou mais recente e selecione View > Tool Windows > Database Inspector na barra de menus.

Para saber mais, consulte Depurar seu banco de dados com o Database Inspector.

Executar o Android Emulator diretamente no Android Studio

Agora, você pode executar o Android Emulator diretamente no Android Studio. Use esse recurso para economizar espaço na tela, para navegar rapidamente entre o emulador e a janela do editor usando teclas de atalho e para organizar o fluxo de trabalho do ambiente de desenvolvimento integrado e do emulador em uma única janela do aplicativo.

Para saber mais, consulte a documentação do Android Emulator.

Usar modelos do TensorFlow Lite

O ML Model Binding facilita a importação direta de arquivos de modelo .tflite e o uso deles nos projetos. O Android Studio gera classes fáceis de usar para que você possa executar seu modelo com menos código e melhor segurança de tipo.

Modelos compatíveis

A implementação atual do ML Model Binding oferece suporte a modelos de classificação de imagem e transferência de estilo, desde que sejam aprimorados com metadados. Com o tempo, o suporte vai ser expandido para outros domínios de problemas, como detecção de objetos, segmentação de imagens e classificação de texto.

Uma grande variedade de modelos pré-treinados com metadados é fornecida no TensorFlow Hub. Também é possível adicionar metadados a um modelo do TensorFlow Lite, conforme descrito em Adding metadata to TensorFlow Lite model (Adicionar metadados ao modelo do TensorFlow Lite).

Importar um arquivo de modelo

Para importar um arquivo de modelo compatível, siga estas etapas:

1. Abra a caixa de diálogo de importação do modelo do TensorFlow Lite no menu File em File > New > Other > TensorFlow Lite Model.
2. Selecione o arquivo de modelo .tflite que você transferiu por download ou criou anteriormente.
3. Clique em Finish.

O arquivo de modelo é importado para o projeto e colocado na pasta ml/. Se o diretório não existe, o Android Studio vai criá-lo para você.

Ver metadados e uso do modelo

Para ver os detalhes de um modelo importado e receber instruções sobre como usá-lo no app, clique duas vezes no arquivo de modelo no projeto para abrir a página do visualizador de modelos, que mostra o seguinte:

• Model: descrição de alto nível do modelo
• Tensors: descrição dos tensores de entrada e saída
• Sample code: exemplo de como interagir com o modelo no app

Veja um exemplo usando mobilenet_v1_0.25_160_quantized.tflite (em inglês):

Como mostrado no exemplo, o Android Studio cria uma classe chamada MobilenetV1025160Quantized para interagir com o modelo.

Se o modelo não tiver metadados, essa tela vai fornecer apenas informações mínimas.

Problemas conhecidos e soluções alternativas

• No momento, o suporte a modelos do TensorFlow Lite para domínios com problemas que não sejam classificação de imagens e transferência de estilos é limitado. Embora a importação funcione bem, algumas entradas e/ou saídas de modelo são representadas por TensorBuffers (link em inglês), em vez de tipos amigáveis. Para modelos sem metadados, todas as entradas e saídas de modelo serão TensorBuffers.
• Não há suporte a modelos com tipos de dados de entrada e saída diferentes de DataType.UINT8 ou DataType.FLOAT32.

Esse recurso ainda está em desenvolvimento. Por isso, forneça feedback ou informe bugs.

Native Memory Profiler

O Memory Profiler do Android Studio agora inclui um Native Memory Profiler para apps implantados em dispositivos físicos que executam o Android 10 ou mais recente. Com o Native Memory Profiler, você pode gravar alocações e desalocações de memória pelo código nativo e inspecionar estatísticas cumulativas sobre objetos nativos.

Para saber mais sobre o Native Memory Profiler, consulte Inspecionar o uso da memória do aplicativo com o Memory Profiler.

Problemas conhecidos e soluções alternativas

• O Native Memory Profiler no Android Studio 4.1 não funciona para dispositivos Android 11. No momento, o suporte a criação de perfil de dispositivos Android 11 está disponível na versão de pré-lançamento do 4.2.

• A partir da versão 4.1 inicial, a criação de perfil de inicialização de aplicativos foi desativada. Essa opção será ativada em uma versão futura.

  Como solução alternativa, você pode usar o Perfetto, um criador de perfil autônomo de linha de comando, para capturar perfis de inicialização.

IU do Rastreamento do sistema: seleção mais fácil, nova guia de análise e mais dados de renderização de frames

A IU de rastreamento do sistema no criador de perfil do Android Studio inclui as seguintes melhorias:

• Seleção de caixa: na seção Threads, você pode arrastar o mouse para executar uma seleção de caixa de uma área retangular, na qual é possível aplicar zoom clicando no botão Zoom to Selection no canto superior direito (ou use o atalho de teclado M). Ao arrastar e soltar linhas de execução semelhantes ao lado uma da outra, você pode selecionar várias linhas de execução para inspecionar todas elas de uma só vez. Por exemplo, é possível executar a análise em várias linhas de execução de worker.

  

• Guia Summary: a nova guia Summary no painel Analysis exibe:

  • Estatísticas agregadas para todas as ocorrências de um evento específico, como uma contagem de ocorrências e duração mínima/máxima.
  • Estatísticas de eventos de rastreamento para a ocorrência selecionada.
  • Dados sobre a distribuição de estado da linha de execução.
  • Ocorrências de execução mais longa do evento de rastreamento selecionado.

  

  Para navegar para outra ocorrência, selecione outra linha na tabela.

• Mostrar dados: na seção Display, os novos cronogramas para SurfaceFlinger e VSYNC investigam problemas de renderização na IU do app.

  

Para ver instruções básicas de uso sobre como gravar um rastreamento do sistema, consulte a seção Gravar rastros de Inspecionar atividade de CPU com o CPU Profiler.

Criadores de perfil autônomos já disponíveis

Com os novos criadores de perfil autônomos, agora é possível definir o perfil do aplicativo sem executar o ambiente de desenvolvimento integrado completo do Android Studio.

Consulte Executar criadores de perfis autônomos para instruções sobre como usá-los.

Suporte de navegação do Dagger

O Android Studio facilita a navegação entre o código relacionado ao Dagger fornecendo novas ações de gutter e ampliando o suporte na janela Find Usages.

• Novas ações de gutter: para projetos que usam o Dagger, o ambiente de desenvolvimento integrado fornece ações de gutter para navegar no código anotado pelo Dagger. Por exemplo, clicar na ação de gutter ao lado de um método que consome um determinado tipo direciona ao provedor desse tipo. Por outro lado, ao clicar na ação de gutter , você navega para onde um tipo é usado como uma dependência.

• Nó Find Usages: quando você invoca Find Usages em um provedor de um determinado tipo, a janela Find agora inclui um consumidor de dependências que lista os consumidores desse tipo. Por outro lado, ao invocar essa ação em um consumidor de uma dependência injetada pelo Dagger, a janela Find mostra o provedor dessa dependência.

Componentes do Material Design: temas e estilos atualizados em novos modelos de projeto

Os modelos do Android Studio na caixa de diálogo Create New Project agora usam Material Design Components (MDC) (em inglês) e seguem as orientações atualizadas para temas e estilos por padrão. As atualizações incluem:

• MDC: os projetos dependem de com.google.android.material:material em build.gradle.. Os temas base do app usam pais Theme.MaterialComponents.* e modificam a cor do MDC atualizada e os atributos "on".
• Recursos de cores: os recursos de cores em colors.xml usam nomes específicos (por exemplo, purple_500 em vez de colorPrimary).
• Recursos de tema: os recursos de tema estão em themes.xml (em vez de styles.xml) e usam nomes Theme.<ApplicationName>.
• Tema escuro: os temas base de apps usam pais DayNight e são divididos entre res/values e res/values-night.
• Atributos de tema: os recursos de cor são referenciados como atributos de tema (por exemplo, ?attr/colorPrimary) em layouts e estilos para evitar cores codificadas.

IntelliJ IDEA 2020.1

O ambiente de desenvolvimento integrado principal do Android Studio foi atualizado com as melhorias do IntelliJ IDEA até a versão 2020.1, incluindo uma nova janela Commit que permite operações de controle de versões e um novo modo Zen que pode ser alternado, selecionando View > Appearance > Enter Distraction Free Mode.

Para saber mais sobre as melhorias na versão 2020.1, consulte a seguinte página:

• IDEA 2020.1

Mudanças no diretório de configuração do ambiente de desenvolvimento integrado

Os locais dos diretórios de configuração do usuário foram alterados para:

Windows

Sintaxe: %APPDATA%\Google\<product><version>

Exemplo: C:\Users\YourUserName\AppData\Roaming\Google\AndroidStudio4.1

macOS

Sintaxe: ~/Library/Application Support/Google/<product><version>

Exemplo: ~/Library/Application Support/Google/AndroidStudio4.1

Linux

Sintaxe: ~/.config/Google/<product><version>

Exemplo: ~/.config/Google/AndroidStudio4.1

Esses novos locais de diretório são consistentes com as atualizações recentes do IntelliJ IDEA (link em inglês), o ambiente de desenvolvimento integrado do Android Studio.

Kotlin 1.3.72

O Android Studio 4.1 vem com o Kotlin 1.3.72, que inclui várias correções para melhorar o destaque, as inspeções e o preenchimento de código do Kotlin. Consulte o registro de alterações do Kotlin 1.3.72 (link em inglês) para ver mais detalhes.

Exibição da visualização personalizada

Ao criar uma visualização personalizada (por exemplo, estendendo a classe View ou Button), o Android Studio agora mostra uma prévia dessa visualização. Use o menu suspenso na barra de ferramentas para alternar entre várias visualizações personalizadas ou clique nos botões para alinhar verticalmente ou horizontalmente ao conteúdo.

Simbolização de relatórios de erros nativos

Quando ocorre uma falha ou um ANR no código nativo, o sistema produz um stack trace, que é um snapshot da sequência de funções aninhadas chamadas no programa até o momento em que ele falhou. Esses snapshots podem identificar e corrigir problemas na origem, mas primeiro precisam ser simbolizados para converter os endereços de máquina de volta em nomes de funções legíveis por humanos.

Caso seu app ou jogo seja desenvolvido usando código nativo, como C++, você pode fazer upload de arquivos de símbolos de depuração para o Play Console de cada versão do app. O Play Console usa esses arquivos de símbolos de depuração para identificar os stack traces do app, facilitando a análise de falhas e ANRs. Para saber como fazer upload de arquivos de símbolos de depuração, consulte Suporte a falhas nativas.

Apply Changes

Para aumentar a produtividade durante a iteração no seu app, fizemos as seguintes melhorias em "Apply Changes" para dispositivos que executam a Prévia do desenvolvedor 3 ou mais recente do Android 11:

Velocidades de implantação mais rápidas

Investimos muito na otimização da velocidade de iteração desenvolvendo um método para implantar e manter alterações em um dispositivo sem instalar o aplicativo. Após uma implantação inicial, as implantações subsequentes feitas nos dispositivos Android 11 com Apply Code Changes ou Apply Changes and Restart Activity agora são muito mais rápidas.

Para saber mais sobre a diferença entre as duas ações, consulte Aplicar mudanças.

Suporte a outras mudanças de código

Para dispositivos que executam a prévia para desenvolvedores 3 ou mais recente do Android 11, agora é possível adicionar métodos e implantar essas mudanças no seu app em execução clicando em Apply Code Changes ou Apply Changes and Restart Activity .

4.0 (maio de 2020)

O Android Studio 4.0 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

Plug-in do Android para Gradle 4.0.0

A versão mais recente do Plug-in do Android para Gradle inclui muitas atualizações, como a simplificação do Java 8 para versões mais antigas do Android e dependências de recurso sobre recurso. Para saber mais, leia as notas da versão completas do Plug-in do Android para Gradle.

Além disso, o Android Studio agora inclui novos recursos para ajudar a melhorar o desempenho de compilação.

Build Analyzer

Ao usar o Android Studio 4.0 com o Plug-in do Android para Gradle 4.0.0 e versões mais recentes, a janela Build Analyzer ajuda a entender e diagnosticar problemas no processo de compilação, como otimizações desativadas e tarefas configuradas incorretamente. Para abrir a janela Build Analyzer, faça o seguinte:

1. Crie seu app selecionando Build > Make Project na barra de menus, caso ainda não tenha feito isso.
2. Selecione View > Tool Windows > Build na barra de menus.
3. Na janela Build, abra a janela Build Analyzer de uma das seguintes maneiras:
   • Depois que o Android Studio concluir a criação do projeto, clique na guia Build Analyzer.
   • Depois que o Android Studio concluir a criação do projeto, clique no link no lado direito da janela Build Output.

A janela do Build Analyzer organiza possíveis problemas de build em uma árvore à esquerda. Inspecione e clique em cada problema para investigar os detalhes no painel à direita. Quando o Android Studio analisa seu build, ele computa o conjunto de tarefas que determinou a duração do build e fornece uma visualização para mostrar o impacto de cada tarefa. Você também pode ver detalhes sobre os avisos expandindo o nó Warnings.

Inspeção das tarefas que determinaram a duração da criação.

Simplificação da biblioteca do Java 8 no D8 e R8

O Android Studio agora oferece suporte ao uso de diversas APIs da linguagem Java 8 sem a necessidade de um nível mínimo de API para o app.

Por um processo conhecido como simplificação, o compilador DEX, D8, no Android Studio 3.0 e versões mais recentes, já fornecia suporte significativo a recursos da linguagem Java 8, como expressões lambda, métodos de interface padrão, try-with-resources, entre outros. No Android Studio 4.0, o mecanismo de simplificação foi estendido para poder simplificar APIs de linguagem Java. Isso significa que agora você pode incluir APIs de linguagem padrão que estavam disponíveis apenas em versões recentes do Android (como java.util.streams) em apps compatíveis com versões mais antigas do Android.

O seguinte conjunto de APIs oferece suporte a essa versão:

• Fluxos sequenciais (java.util.stream)
• Um subconjunto de java.time
• java.util.function
• Adições recentes a java.util.{Map,Collection,Comparator}
• Recursos opcionais (java.util.Optional, java.util.OptionalInt e java.util.OptionalDouble) e algumas outras novas classes úteis com as APIs acima
• Algumas adições a java.util.concurrent.atomic (novos métodos em AtomicInteger, AtomicLong e AtomicReference)
• ConcurrentHashMap (com correções de bugs para o Android 5.0)

Para oferecer suporte a essas APIs de linguagem, o D8 compila um arquivo DEX de biblioteca separado que contém uma implementação das APIs ausentes e as inclui no app. O processo de simplificação reprograma o código do app para usar essa biblioteca no momento da execução.

Para ativar o suporte a essas APIs de linguagem, inclua o seguinte no arquivo build.gradle do módulo do app:

android {
    defaultConfig {
        // Required when setting minSdkVersion to 20 or lower
        multiDexEnabled true
    }

    compileOptions {
        // Flag to enable support for the new language APIs
        coreLibraryDesugaringEnabled true
        // Sets Java compatibility to Java 8
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

dependencies {
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.0.4'
}

android {
    defaultConfig {
        // Required when setting minSdkVersion to 20 or lower
        multiDexEnabled = true
    }

    compileOptions {
        // Flag to enable support for the new language APIs
        coreLibraryDesugaringEnabled = true
        // Sets Java compatibility to Java 8
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
}

dependencies {
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:1.0.4")
}

Também pode ser necessário incluir o snippet de código acima em um arquivo build.gradle do módulo da biblioteca se:

• os testes de instrumentação do módulo da biblioteca usam essas APIs de linguagem, seja diretamente, pelo módulo da biblioteca ou pelas dependências dele; dessa forma, as APIs que não estiverem presentes vão ser fornecidas para o APK de teste de instrumentação;

• você quer executar o lint no módulo da biblioteca de forma isolada. O objetivo é ajudar o lint a reconhecer usos válidos das APIs de linguagem e evitar avisos falsos.

Dependências de recurso sobre recurso

Nas versões anteriores do Plug-in do Android para Gradle, todos os módulos de recursos podiam depender apenas do módulo base do app. Ao usar o Plug-in do Android para Gradle 4.0.0 e versões mais recentes, agora é possível incluir um módulo de recursos que dependa de outro módulo de recurso. Ou seja, um recurso :video pode depender do recurso :camera, que depende do módulo base, como mostrado na figura abaixo.

O módulo de recurso :video depende do recurso :camera, que depende do módulo base :app.

Isso significa que, quando o app pede o download de um módulo de recurso, ele também faz o download de outros módulos de recursos de que depende. Depois de criar módulos de recursos para seu app, você pode declarar uma dependência de recursos no arquivo build.gradle do módulo. Por exemplo, o módulo :video declara uma dependência de :camera da seguinte maneira:

// In the build.gradle file of the ':video' module.
dependencies {
    // All feature modules must declare a dependency
    // on the base module.
    implementation project(':app')
    // Declares that this module also depends on the 'camera' feature module.
    implementation project(':camera')
    ...
}

// In the build.gradle file of the ':video' module.
dependencies {
    // All feature modules must declare a dependency
    // on the base module.
    implementation(project(":app"))
    // Declares that this module also depends on the 'camera' feature module.
    implementation(project(":camera"))
    ...
}

Além disso, ative a função de dependência de recurso sobre recurso no Android Studio para oferecer suporte ao editar a configuração de execução, por exemplo. Faça isso clicando em Help > Edit Custom VM Options na barra de menus e incluindo o código abaixo:

-Drundebug.feature.on.feature=true

Metadados de dependências

Quando você cria seu app usando o Plug-in do Android para Gradle 4.0.0 e mais recente, o plug-in inclui metadados que descrevem as dependências compiladas no app. Durante o upload do app, o Play Console inspeciona esses metadados para oferecer os seguintes benefícios:

• Receber alertas de problemas conhecidos com os SDKs e as dependências que o app usa
• Receber feedback útil para resolver esses problemas

Os dados são compactados, criptografados por uma chave de assinatura do Google Play e armazenados no bloco de assinatura do app de lançamento. No entanto, você pode inspecionar os metadados por conta própria nos arquivos de build intermediários locais no seguinte diretório: <project>/<module>/build/outputs/sdk-dependencies/release/sdkDependency.txt.

Se você preferir não compartilhar essas informações, inclua o seguinte no arquivo build.gradle do módulo:

android {
    dependenciesInfo {
        // Disables dependency metadata when building APKs.
        includeInApk = false
        // Disables dependency metadata when building Android App Bundles.
        includeInBundle = false
    }
}

android {
    dependenciesInfo {
        // Disables dependency metadata when building APKs.
        includeInApk = false
        // Disables dependency metadata when building Android App Bundles.
        includeInBundle = false
    }
}

Suporte a arquivos de script DSL do Kotlin

O Plug-in do Android para Gradle agora oferece suporte a arquivos de script de build DSL do Kotlin (*.kts). Quando usados com o Android Studio, alguns recursos do ambiente de desenvolvimento integrado, como a caixa de diálogo "Project Structure" e correções rápidas de scripts de build, agora também têm suporte a leitura e gravação em arquivos de script de build do Kotlin.

Upgrades do CPU Profiler

Com base no seu feedback, nós concentramos nossos esforços em melhorar a experiência do usuário no CPU Profiler de duas maneiras importantes.

Primeiro, em comparação com versões anteriores do Android Studio, as taxas de erro em gravações da CPU no CPU Profiler foram reduzidas significativamente.

Em segundo lugar, a IU do CPU Profiler foi revisada para fornecer um fluxo de trabalho mais intuitivo. Estas são algumas mudanças importantes na IU:

• As gravações da CPU agora são separadas da linha do tempo principal do criador de perfil para facilitar a análise. Os dados gravados são organizados em grupos no lado esquerdo da janela Profiler. É possível mover grupos para cima e para baixo para reorganizar a lista, clicando no ícone de opções  no canto direito de cima da janela ou arrastando e soltando itens individuais em um grupo.
• Para facilitar a análise lado a lado, agora você pode ver toda a atividade de linha de execução na linha do tempo de atividades (incluindo métodos, funções e eventos). Há várias maneiras de navegar na linha do tempo:
  • Para se concentrar em um ponto específico no tempo, arraste um intervalo no gráfico de uso da CPU no canto superior esquerdo.
  • Para aumentar ou diminuir o zoom, use a roda do mouse mantendo o botão Control (ou Command no MacOS) pressionado. Para movimentar para a esquerda ou para a direita, arraste a barra de espaço enquanto você a mantém pressionada.
  • Como alternativa, use as teclas W e A para ampliar e reduzir o zoom e as teclas S e D para uma movimentação à esquerda e à direita.
• As guias das análises Flame Chart, Top Down e Bottom Up agora estão na coluna direita. No grupo Threads, as linhas de execução são automaticamente expandidas para as gravações do Rastreamento do sistema e recolhidas por padrão para outros tipos de registro. Clique duas vezes (ou pressione Enter) nos nomes das linhas de execução para expandi-las ou recolhê-las.
• A IU do Rastreamento do sistema, como mostrado na captura de tela, também inclui melhorias:
  • Os eventos agora são coloridos de forma exclusiva para facilitar a diferenciação.
  • As linhas de execução são classificadas pelo número de eventos de rastreamento nelas. Assim, as linhas de execução "mais ocupadas" são classificadas mais acima na lista.
  • É possível selecionar uma ou mais linhas de execução para ver a análise na coluna à direita apenas das linhas selecionadas.
  • Da mesma forma, é possível selecionar um evento de rastreamento dentro de qualquer linha de execução para ver os dados de análise dele.

Ferramentas de design

Esta versão do Android Studio inclui atualizações das ferramentas de design, como o Layout Inspector e um novo Motion Editor.

Novo Motion Editor

O Android Studio agora inclui um editor de design visual para o tipo de layout MotionLayout, facilitando a criação e visualização de animações.

O Motion Editor oferece uma interface simples para processar elementos da biblioteca MotionLayout, que serve como base para a animação em apps Android. Nas versões anteriores, a criação e a mudança desses elementos precisavam da edição manual de restrições em arquivos de recurso XML. Agora, o Motion Editor pode gerar esse XML para você, oferecendo suporte a estados de início e fim, frames-chave, transições e linhas do tempo.

Para saber mais sobre como usar o Motion Editor, consulte o guia do usuário.

Live Layout Inspector

Depure seu layout com o Live Layout Inspector atualizado, que fornece informações completas e em tempo real sobre a IU do seu app durante a implantação em um dispositivo.

Para abrir uma janela do Layout Inspector, vá para View > Tools Windows > Layout Inspector. Além dos mesmos recursos do Layout Inspector existente, o Live Layout Inspector também inclui:

• Hierarquia de layout dinâmica: é atualizada à medida que as visualizações do dispositivo mudam.

• Pilha de resolução de valores de propriedades: investiga onde um valor de propriedade de recurso se origina no código-fonte e navega até o local seguindo os hiperlinks do painel Properties.

• Visualização em 3D: veja a hierarquia de visualização do app no momento da execução com a visualização 3D avançada. Para usar esse recurso, na janela Live Layout Inspector, clique no layout e gire-o.

Você pode usar o Live Layout Inspector somente ao implantar seu aplicativo em um dispositivo ou emulador com a API de nível 29 ou mais recente. Para ativar o Live Layout Inspector, acesse File > Settings > Experimental e marque a caixa ao lado de Enable Live Layout Inspector. Em seguida, clique na caixa de seleção ao lado de Live updates acima de Layout Display.

Validação de layout

A Validação de layout é uma ferramenta para ver simultaneamente layouts em diferentes dispositivos e configurações, detectando erros de layout e criando aplicativos mais acessíveis.

Você pode acessar esse recurso, clicando na guia Layout Validation no canto superior direito da janela do ambiente de desenvolvimento integrado:

Na janela Layout Validation, você pode selecionar entre quatro conjuntos de configurações diferentes, incluindo:

• Pixel Devices: visualize seu app em uma seleção de dispositivos Pixel.
• Custom: visualize seu app usando opções de exibição personalizada, como orientação da tela ou idioma.
• Color Blind: visualize seu app usando simulações de tipos comuns de daltonismo.
• Font Sizes: visualize seu app usando diversos tamanhos de fonte.

Para saber mais sobre o uso da Validação de layout, consulte Depurar seu layout com o Layout Inspector.

Recursos do editor inteligente para regras de redutor de código

O Android Studio agora oferece recursos do editor inteligente quando você abre arquivos de regras de redutor de código para R8, como destaque de sintaxe, preenchimento de código e verificação de erros. O editor também se integra ao projeto do Android Studio para fornecer o preenchimento completo de símbolos a todas as classes, métodos e campos, além de incluir navegação rápida e refatoração.

Modelos dinâmicos do Kotlin para Android

O Android Studio agora inclui modelos dinâmicos do Android para suas classes Kotlin. Por exemplo, agora você pode digitar toast e pressionar a tecla Tab para inserir rapidamente um aviso. Para ver uma lista completa dos modelos dinâmicos disponíveis, clique em File > Settings na barra de menus (ou Android Studio > Preferences no macOS) e navegue até Editor > Live Templates.

Assistente de fragmento e novos modelos de fragmento

Um novo assistente de fragmentos do Android e novos modelos de fragmento agora estão disponíveis quando você acessa File > New > Fragment > Gallery ou clica em Create new destination no editor de navegação.

Suporte a câmera expandida no emulador do Android

Ao usar a imagem do Android 11, a câmera do Android Emulator inclui os novos recursos a seguir:

• Captura RAW
• Reprocessamento YUV
• Dispositivos de nível 3
• Compatibilidade lógica da câmera

Para saber mais sobre o desenvolvimento para o Android 11, consulte a documentação do Android 11.

O clangd está disponível para o editor de código C++

O CLion da JetBrains, tecnologia que sustenta o suporte à linguagem C++ do Android Studio, agora usa um mecanismo de inspeção baseado em clangd e clang-tidy (em inglês) do LLVM, acelerando o preenchimento de código do C/C++ e fornecendo integração perfeita com clang-tidy.

Agora disponíveis no editor de código C++ do Android Studio, clangd e clang-tidy fazem parte das ferramentas extras do LLVM de código aberto:

• O clangd conta com preenchimento automático de código, mensagens de erro de compilação no editor e a navegação go-to-definition.
• O clang-tidy é uma ferramenta de inspeção C++ com uma biblioteca extensível para diagnosticar e corrigir erros típicos de programação.

Em versões anteriores, os usuários do Android Studio podiam usar clang-tidy pelo NDK. Com essa mudança, o Android Studio não depende mais do NDK para a funcionalidade do clang-tidy.

A configuração do ndk.dir no arquivo local.properties foi descontinuada

O valor de ndk.dir não deve mais ser definido no arquivo local.properties do app, e o suporte a essa configuração ndk.dir vai ser removido em uma versão futura. O Plug-in do Android para Gradle define a versão do NDK por padrão, mas se você precisar de uma versão específica do NDK, defina android.ndkVersion em build.gradle.

Para saber mais sobre a configuração do NDK, consulte Instalar e configurar o NDK e o CMake.

IntelliJ IDEA 2019.3.3

O ambiente de desenvolvimento integrado principal do Android Studio foi atualizado com melhorias da versão 2019.3.3 do IntelliJ IDEA.

Para saber mais sobre as melhorias de outras versões do IntelliJ incluídas cumulativamente na versão 2019.3.3, consulte as seguintes páginas (em inglês):

• IntelliJ IDEA 2019.3
• IntelliJ IDEA 2019.3.3

3.6 (fevereiro de 2020)

O Android Studio 3.6 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

Também gostaríamos de agradecer a todos os nossos colaboradores da comunidade que ajudaram nesta versão.

Ferramentas de design

Esta versão do Android Studio inclui atualizações para várias ferramentas de design, incluindo o Layout Editor e o Resource Manager.

Dividir visualização e aumentar zoom nos editores de design

As seguintes atualizações dos editores de design visual estão incluídas nesta versão:

• Editores de design, como o Layout Editor e o Navigation Editor, agora fornecem uma visualização Split que permite que você veja as visualizações Design e Code da IU ao mesmo tempo. No canto superior direito da janela do editor, agora há três botões para alternar entre as opções de visualização:

  • Para ativar a visualização dividida, clique no ícone Split .
  • Para ativar a visualização de origem XML, clique no ícone Source .
  • Para ativar a visualização de design, clique no ícone Design .

• Os controles de zoom e panorâmica nos editores de design foram movidos para um painel flutuante no canto inferior direito da janela do editor.

Para saber mais, consulte Criar uma IU com o Layout Editor.

Guia de recursos do seletor de cores

Para atualizar rapidamente os valores de recursos de cores no app quando você estiver usando o seletor de cores no XML ou nas ferramentas de design, o ambiente de desenvolvimento integrado agora vai preencher os valores de recursos de cores para você.

Resource Manager

O Resource Manager contém as seguintes atualizações:

• O Resource Manager agora é compatível com a maioria dos tipos de recursos.
• Ao pesquisar um recurso, o Resource Manager agora mostra os resultados de todos os módulos do projeto. Anteriormente, as pesquisas retornavam resultados apenas do módulo selecionado.
• O botão de filtro permite ver recursos de módulos dependentes locais, bibliotecas externas e a estrutura do Android. Você também pode usar o filtro para mostrar os atributos do tema.
• Agora você pode renomear recursos durante o processo de importação clicando na caixa de texto acima do recurso.

Para saber mais, consulte Gerenciar os recursos de IU do app com o Resource Manager.

Atualizações no Plug-in do Android para Gradle

A versão mais recente do Plug-in do Android para Gradle conta com muitas atualizações, incluindo otimizações da velocidade do build e suporte ao plug-in do Maven e à vinculação de visualizações. Para saber mais, leia as notas da versão completas.

Vinculação de visualizações

A vinculação de visualizações permite que você programe com mais facilidade um código que interaja com visualizações gerando uma classe de vinculação para cada arquivo de layout XML. Essas classes contêm referências diretas a todas as visualizações que têm um ID no layout correspondente.

Como a vinculação de visualizações substitui findViewById(), ela elimina o risco de exceções de ponteiro nulo resultantes de um ID de visualização inválido.

Para ativar a vinculação de visualizações, você precisa usar o Plug-in do Android para Gradle versão 3.6.0 ou mais recente e incluir o seguinte no arquivo build.gradle de cada módulo:

android {
    buildFeatures.viewBinding = true
}

android {
    buildFeatures.viewBinding = true
}

Apply Changes

Agora você pode adicionar uma classe e implantar essa mudança de código no app em execução clicando em Apply Code Changes  ou em Apply Changes and Restart Activity .

Para saber mais sobre a diferença entre as duas ações, consulte Aplicar mudanças.

Refatorar a opção de menu para ativar o suporte a Instant Apps

Agora, é possível ativar instantaneamente seu módulo base a qualquer momento depois de criar o projeto do app da seguinte maneira:

1. Abra o painel Project, selecionando View > Tool Windows > Project na barra de menus.
2. Clique com o botão direito no módulo base, normalmente chamado de "app", e selecione Refactor > Enable Instant Apps Support.
3. Na caixa de diálogo exibida, selecione o módulo base no menu suspenso.
4. Clique em OK.

Para saber mais, leia Visão geral do Google Play Instant.

Desofuscar o bytecode de classe e método no APK Analyzer

Ao usar o APK Analyzer para inspecionar arquivos DEX, é possível desofuscar o bytecode de classe e método da seguinte maneira:

1. Selecione Build > Analyze APK na barra de menus.
2. Na caixa de diálogo mostrada, navegue até o APK que você quer inspecionar e o selecione.
3. Clique em Open.
4. No APK Analyzer, selecione o arquivo DEX que você quer inspecionar.
5. No visualizador de arquivos DEX, carregue o arquivo de mapeamentos ProGuard para o APK que você está analisando.
6. Clique com o botão direito do mouse na classe ou no método que você quer inspecionar e selecione Show bytecode.

Ferramentas nativas

As seguintes atualizações são compatíveis com o desenvolvimento nativo (C/C++) no Android Studio.

Compatibilidade com o Kotlin

Os recursos do NDK abaixo no Android Studio, anteriormente com suporte do Java, agora também tem suporte do Kotlin:

• Navegue de uma declaração JNI para a função de implementação correspondente em C/C++. Para ver essa associação, passe o cursor sobre o marcador de item C ou C++ próximo ao número da linha no arquivo de código-fonte gerenciado.

• Crie automaticamente uma função de implementação de stub para uma declaração JNI. Defina a declaração JNI primeiro e, em seguida, digite “jni” ou o nome do método no arquivo C/C++ a ser ativado.

  

• As funções de implementação nativa não utilizadas são destacadas como avisos no código-fonte. Declarações JNI com implementações ausentes também são destacadas como erros.

• Quando você renomeia (refatora) uma função de implementação nativa, todas as declarações JNI correspondentes são atualizadas. Renomeie uma declaração JNI para atualizar a função de implementação nativa.

• Verificação de assinatura para implementações de JNI vinculadas implicitamente.

Outras melhorias do JNI

O editor de código no Android Studio agora oferece suporte a um fluxo de trabalho de desenvolvimento de JNI mais integrado, incluindo dicas aprimoradas de tipo, preenchimento automático, inspeções e refatoração de código.

Recarregamento do APK para bibliotecas nativas

Não é mais necessário criar um novo projeto quando o APK do seu projeto é atualizado fora do ambiente de desenvolvimento integrado. O Android Studio detecta mudanças no APK e oferece a opção de importá-lo novamente.

Anexar origens de APKs somente para Kotlin

Agora é possível anexar origens de APK externas exclusivas do Kotlin quando você cria perfis e depura APKs pré-criados. Para saber mais, consulte Anexar origens Kotlin/Java.

Detecção de vazamento no Memory Profiler

Ao analisar um heap dump no Memory Profiler, agora é possível filtrar dados de criação de perfil que o Android Studio considera vazamentos de memória em instâncias de Activity e Fragment do seu app.

Os tipos de dados mostrados pelo filtro incluem o seguinte:

• Instâncias de Activity que foram destruídas, mas ainda estão sendo referenciadas.
• Instâncias de Fragment que não têm um FragmentManager, mas ainda estão sendo referenciadas.

Em determinadas situações, como as seguintes, o filtro pode gerar falsos positivos:

• Um Fragment foi criado, mas ainda não foi usado.
• Um Fragment está sendo armazenado em cache, mas não como parte de um FragmentTransaction.

Para usar esse recurso, primeiro capture um heap dump ou importe um arquivo de heap dump para o Android Studio. Para mostrar os fragmentos e atividades que podem estar vazando memória, marque a caixa de seleção Activity/Fragment Leaks no painel de heap dump do Memory Profiler.

Filtragem de um despejo de heap em busca de vazamentos de memória.

Emuladores

O Android Studio 3.6 ajuda você a aproveitar as diversas atualizações incluídas no Android Emulator 29.2.7 ou mais recente, conforme descrito abaixo.

Compatibilidade aprimorada para local

O Android Emulator 29.2.7 e versões mais recentes oferecem mais suporte à emulação de coordenadas de GPS e informações de rota. Quando você abre os Controles estendidos dos emuladores, as opções na guia "Location" agora estão organizadas em duas guias: Single points e Routes.

Single points

Na guia Single points, você pode usar a visualização da Web do Google Maps para pesquisar pontos de interesse, assim como faria ao usar o Google Maps em um smartphone ou navegador. Ao pesquisar ou clicar em um local no mapa, você pode salvar o local selecionando "Save point" próximo à parte inferior do mapa. Todos os seus locais salvos são listados no lado direito da janela Extended controls.

Para definir o local dos emuladores como o local que você selecionou no mapa, clique no botão Set location perto do canto inferior direito da janela Extended controls.

.

Routes

Semelhante à guia Single points, a guia Routes fornece uma visualização da Web do Google Maps que você pode usar para criar um trajeto entre dois ou mais locais. Para criar e salvar uma rota, faça o seguinte:

1. Na visualização de mapa, use o campo de texto para pesquisar o primeiro destino no seu trajeto.
2. Selecione o local nos resultados da pesquisa.
3. Selecione o botão Navegar .
4. Selecione o ponto de partida do seu trajeto no mapa.
5. (Opcional) Clique em Add destination para adicionar mais paradas ao trajeto.
6. Salve seu trajeto clicando em Save route na visualização do mapa.
7. Especifique um nome para o trajeto e clique em Save.

Para simular o emulador seguindo o trajeto que você salvou, selecione o trajeto na lista de Saved routes e clique em Play route próximo ao canto inferior direito da janela Extended controls. Para interromper a simulação, clique em Stop route.

.

Para simular continuamente o emulador seguindo o trajeto especificado, ative a chave ao lado de Repeat playback. Para mudar a velocidade com que o emulador segue o trajeto especificado, selecione uma opção na lista suspensa Playback speed.

Suporte a várias telas

O Android Emulator agora permite implantar o app em várias telas, que oferecem suporte a dimensões personalizáveis e podem testar apps com suporte a várias janelas e várias telas. Enquanto um dispositivo virtual está em execução, é possível colocar até duas telas adicionais da seguinte maneira:

1. Abra Extended controls e navegue até a guia Displays.
2. Adicione outra exibição clicando em Add secondary display.

3. No menu suspenso em Secondary displays, siga um destes procedimentos:

   1. Selecione uma das proporções predefinidas
   2. Selecione custom e defina height (altura), width (largura) e dpi para a tela personalizada.

4. (Opcional) Clique em Add secondary display para adicionar uma terceira exibição.

5. Clique em Apply changes para adicionar as telas especificadas ao dispositivo virtual em execução.

Novos dispositivos virtuais e modelos de projeto para o SO Android Automotive

Ao criar um novo projeto usando o Android Studio, agora você pode selecionar entre três modelos na guia Automotive no assistente Create New Project: No Activity, Media service e Messaging service. Para projetos já existentes, você pode adicionar suporte a dispositivos Android Automotive selecionando File > New > New Module na barra de menus e selecionando Automotive Module. O assistente Create New Module orienta você na criação de um novo módulo usando um dos modelos de projeto do Android Automotive.

.

Além disso, agora você pode criar um Dispositivo virtual Android (AVD, na sigla em inglês) para dispositivos Android Automotive OS selecionando uma das seguintes opções na guia Automotive no assistente Configurador do dispositivo virtual.

1. Polestar 2: crie um AVD que emule a unidade principal do Polestar 2.
2. Automotive (paisagem 1.024p): crie um AVD para unidades genéricas do Android Automotive de 1024 x 768 px.

.

Downloads recuperáveis do SDK

Ao fazer o download de componentes e ferramentas do SDK usando o SDK Manager, o Android Studio permite retomar downloads interrompidos (por exemplo, devido a um problema de rede) em vez de reiniciá-los desde o começo. Essa melhoria é especialmente útil para downloads grandes, como do Android Emulator ou de imagens do sistema, quando a conectividade de Internet não é confiável.

Além disso, se você tem uma tarefa de download do SDK em execução em segundo plano, é possível pausar ou retomar o download usando os controles na barra de status.

Uma tarefa de download em segundo plano na barra de status com novos controles que permitem pausar ou retomar o download.

Descontinuação do Win32

A versão para Windows de 32 bits do Android Studio não vai mais receber atualizações após dezembro de 2019, nem suporte após dezembro de 2020. Você pode continuar usando o Android Studio. No entanto, para receber atualizações adicionais, faça upgrade da sua estação de trabalho para uma versão de 64 bits do Windows.

Para saber mais, leia a postagem no blog sobre a descontinuação do Windows de 32 bits (em inglês).

Nova opção para otimizar o tempo de sincronização do Gradle

Nas versões anteriores, o Android Studio recuperava a lista de tarefas do Gradle durante a sincronização com o Gradle. Em projetos grandes, recuperar a lista de tarefas pode causar lentidão nos tempos de sincronização.

Para melhorar a performance da sincronização do Gradle, acesse File > Settings > Experimental e selecione "Do not build Gradle task list during Gradle sync".

Quando você ativa essa opção, o Android Studio pula a criação da lista de tarefas durante a sincronização, o que permite que a sincronização do Gradle seja concluída mais rapidamente e melhora a capacidade de resposta da IU. Não se esqueça de que, quando o IDE pula a criação da lista de tarefas, as listas de tarefas no painel do Gradle ficam vazias, e o preenchimento automático do nome da tarefa nos arquivos do build não funciona.

Novo local para alternar o modo off-line do Gradle

Para ativar ou desativar o modo off-line do Gradle, selecione View > Tool Windows > Gradle na barra de menus. Em seguida, na parte superior da janela Gradle, clique em Toggle Offline Mode .

IntelliJ IDEA 2019.2

O ambiente de desenvolvimento integrado principal do Android Studio foi atualizado com melhorias da versão 2019.2 do IntelliJ IDEA.

Para saber mais sobre as melhorias de outras versões do IntelliJ incluídas cumulativamente na versão 2019.2, consulte as seguintes páginas (em inglês):

• IntelliJ IDEA 2019.1.3
• IntelliJ IDEA 2019.1.2
• IntelliJ IDEA 2019.1.1

Colaboradores da comunidade

Agradecemos a todos os colaboradores da comunidade que nos ajudaram a descobrir bugs e outras formas de melhorar o Android Studio 3.6. Em particular, gostaríamos de agradecer às seguintes pessoas que relataram bugs:

3.5 (agosto de 2019)

O Android Studio 3.5 é uma versão principal que resultou do Project Marble. A partir do lançamento do Android Studio 3.3, a iniciativa do Project Marble deu origem a várias versões que se concentram na melhoria de três áreas principais do ambiente de desenvolvimento integrado: integridade do sistema, aperfeiçoamento de recursos e correção de bugs.

Para ver mais informações sobre essas e outras atualizações do Project Marble, leia a postagem no Blog de desenvolvedores Android (em inglês) ou as seções abaixo.

Também gostaríamos de agradecer a todos os nossos colaboradores da comunidade que ajudaram com esta versão.

Project Marble: integridade do sistema

Esta seção descreve as mudanças no Android Studio 3.5 com foco na melhoria da integridade do sistema.

Configurações de memória recomendadas

O Android Studio notificará você caso detecte que pode melhorar o desempenho aumentando a quantidade máxima de memória RAM que seu sistema operacional precisa alocar para processos do Android Studio, como ambiente de desenvolvimento integrado principal, daemon do Gradle e daemon do Kotlin. Você pode aceitar as configurações recomendadas clicando no link de ação na notificação ou pode ajustar essas configurações manualmente selecionando File > Settings (ou Android Studio > Preferences no macOS), encontrando a seção Memory Settings em Appearance & Behavior > System Settings. Para saber mais, consulte Tamanho máximo de heap.

Notificação sobre as configurações recomendadas de memória.

Relatório de uso de memória

Às vezes, os problemas de memória no Android Studio são difíceis de reproduzir e informar. Para resolver esse problema, o Android Studio permite gerar um relatório de uso de memória, clicando em Help > Analyze Memory Usage na barra de menus. Ao fazer isso, o ambiente de desenvolvimento integrado limpa localmente os dados de informações pessoais antes de perguntar se você quer enviá-los à equipe do Android Studio para identificar a origem dos problemas de memória. Para saber mais, consulte Executar um relatório de uso da memória.

Um relatório de uso da memória.

Windows: otimização de E/S de arquivos antivírus

O Android Studio agora verifica automaticamente se determinados diretórios de projeto são excluídos da verificação antivírus em tempo real. Quando ajustes podem ser feitos para melhorar a performance da versão, o Android Studio notifica você e fornece instruções sobre como otimizar a configuração do seu antivírus. Para saber mais, consulte Minimizar o impacto do software antivírus na velocidade do build.

Project Marble: aperfeiçoamento de recursos

Esta seção descreve as mudanças no Android Studio 3.5 com foco na melhoria dos recursos já existentes.

Apply Changes

Com o recurso Apply Changes, você pode enviar mudanças de código e recursos ao aplicativo em execução sem reiniciar o aplicativo e, em alguns casos, sem reiniciar a atividade atual. Esse recurso implementa uma abordagem completamente nova para preservar o estado do seu aplicativo. Ao contrário do Instant Run, que reescreveu o bytecode do APK, o Apply Changes redefine classes em tempo real aproveitando a instrumentação no tempo de execução compatível com Android 8.0 (API de nível 26) ou mais recente.

Para saber mais, consulte Apply Changes.

Botões da barra de ferramentas para "Apply Changes".

Fluxo de implantação de apps

O ambiente de desenvolvimento integrado tem um novo menu suspenso que permite selecionar rapidamente em qual dispositivo você quer implantar seu app. Esse menu também inclui uma nova opção que permite executar o app em vários dispositivos ao mesmo tempo.

Menu suspenso do dispositivo de destino.

Sincronização aprimorada do Gradle e detecção do cache

Agora o ambiente de desenvolvimento integrado detecta melhor quando o Gradle limpa periodicamente o cache da sua versão ao reduzir o consumo do disco rígido. Nas versões anteriores, esse estado fazia o ambiente de desenvolvimento integrado reportar dependências ausentes e a sincronização do Gradle falhar. Agora, o ambiente de desenvolvimento integrado faz o download das dependências conforme o necessário para garantir que a sincronização do Gradle seja concluída.

Saída do erro de build aprimorada

A janela Build agora fornece melhores relatórios de erros, como um link para o arquivo e a linha do erro informado, para os seguintes processos de compilação:

• Compilação e vinculação de AAPT
• R8 e ProGuard
• Dexing
• Mescla de recursos
• Análise do arquivo XML
• Compilação Javac, Kotlinc e CMake

Upgrades de projeto

Melhoria na experiência de atualização para fornecer mais informações e ações a fim de ajudar a atualizar o ambiente de desenvolvimento integrado e o Plug-in do Android para Gradle. Por exemplo, mais erros de sincronização e de build incluem ações para reduzir erros ao atualizar.

É importante lembrar que você pode atualizar o ambiente de desenvolvimento integrado independe de outros componentes, como o Plug-in do Android para Gradle. Assim, você pode atualizar o ambiente de desenvolvimento integrado com segurança assim que uma versão mais recente é disponibilizada e atualizar outros componentes depois.

Layout Editor

O Android Studio 3.5 inclui várias melhorias na visualização, no gerenciamento e na interação de layouts.

Ao trabalhar com ConstraintLayout, uma nova seção Constraints no painel Attributes lista as relações de restrições do componente de IU selecionado. Você pode selecionar uma restrição na superfície de design ou na lista de restrições para destacar a restrição em ambas as áreas.

Relações de restrição para um elemento de IU selecionado.

Da mesma forma, agora você pode excluir uma restrição selecionando-a e pressionando a tecla Delete. Você também pode excluir uma restrição mantendo a tecla Control (Command no macOS) pressionada e clicando no ponto de fixação da restrição. Quando você mantém a tecla Control ou Command pressionada e passa o cursor sobre um ponto de fixação, as restrições associadas ficam vermelhas para indicar que você pode clicar para as excluir.

Quando uma visualização é selecionada, você pode criar uma restrição clicando em qualquer um dos ícones + na seção Constraint Widget do painel Attributes, como mostrado na imagem abaixo. Quando você cria uma nova restrição, o Layout Editor agora seleciona e destaca a restrição, fornecendo feedback visual imediato para o que você acabou de adicionar.

Uso do widget de restrição para criar restrições

Ao criar uma restrição, o Layout Editor agora mostra apenas os pontos de fixação qualificados que você pode restringir. Anteriormente, o Layout Editor destacava todos os pontos de fixação em todas as visualizações, independente de você poder ou não se restringir a elas. Além disso, uma sobreposição azul agora destaca a meta da restrição. Esse destaque é particularmente útil ao tentar restringir a um componente que se sobrepõe a outro.

Como criar uma restrição para um componente de sobreposição no Android Studio 3.4.

Como criar uma restrição para um componente de sobreposição no Android Studio 3.5.

Além das atualizações acima, o Android Studio 3.5 também contém os seguintes aprimoramentos do Layout Editor:

• O Constraint Widget e o menu suspenso de margem padrão agora permitem que você use recursos de dimensão para margens.
• Na barra de ferramentas do Layout Editor, a lista de dispositivos que determinam o tamanho da superfície de design foi atualizada. Além disso, o comportamento de ajuste durante o redimensionamento foi aprimorado, e as alças de redimensionamento na superfície de design agora estão sempre visíveis. Ao redimensionar, novas sobreposições aparecem e mostram tamanhos de dispositivos comuns.
• O Layout Editor tem um novo esquema de cores que melhora a consistência e reduz o contraste entre componentes, texto e restrições.
• O modo Blueprint agora inclui suporte de texto para alguns componentes em que o texto não estava sendo mostrado.

Para ver mais informações sobre essas mudanças, consulte Project Marble do Android Studio: Layout Editor.

Vinculação de dados

Além de adicionar compatibilidade incremental com processamento de anotações para vinculação de dados, o ambiente de desenvolvimento integrado melhora os recursos e o desempenho do editor inteligente, criando expressões de vinculação de dados em XML.

Desempenho do editor de código no Android Studio 3.4.

Melhor desempenho de edição de código no Android Studio 3.5.

Compatibilidade aprimorada para projetos C/C++

O Android Studio 3.5 inclui várias mudanças que melhoram o suporte a projetos C/C++.

Melhorias no painel "Build Variants" para sincronização de variante única

Agora você pode especificar a variante de build ativa e a ABI ativa no painel Build Variants. Esse recurso simplifica a configuração do build por módulo e também pode melhorar a performance da sincronização do Gradle.

Para saber mais, consulte Mudar a variante de build.

O painel "Build Variants" com seleção de variante única da ABI.

Versões lado a lado do NDK

Agora você pode usar várias versões do NDK lado a lado. Esse recurso oferece mais flexibilidade ao configurar seus projetos, por exemplo, se você tem projetos que usam diferentes versões do NDK na mesma máquina.

Se o projeto usa o Plug-in do Android para Gradle 3.5.0 ou mais recente, você também pode especificar a versão do NDK que cada módulo do seu projeto vai usar. Você pode usar esse recurso para criar versões reproduzíveis e reduzir as incompatibilidades entre as versões do NDK e o Plug-in do Android para Gradle.

Para saber mais, consulte Instalar e configurar NDK, CMake e LLDB.

Compatibilidade com Chrome OS

O Android Studio agora é oficialmente compatível com dispositivos Chrome OS, como o Chromebook HP x360 14, o Chromebook Acer 13/Spin 13 e outros, sobre os quais você pode ler nos requisitos do sistema. Para começar, faça o download do Android Studio no dispositivo Chrome OS compatível e siga as instruções de instalação.

Entrega condicional para módulos de recursos

A entrega condicional permite que você defina alguns requisitos de configuração de dispositivos para que os módulos de recursos sejam transferidos por download automaticamente durante a instalação do app. Por exemplo, você pode configurar um módulo de recursos que inclua a funcionalidade de realidade aumentada (RA) disponível na instalação do app apenas para dispositivos com suporte à RA.

No momento, esse mecanismo de entrega permite controlar o download de um módulo no momento da instalação do app com base nas seguintes configurações de dispositivos:

• Recursos de hardware e software do dispositivo, incluindo a versão do OpenGL ES
• País do usuário
• Nível da API

Se um dispositivo não atender a todos os requisitos especificados, o módulo não vai ser transferido por download no momento da instalação do app. No entanto, o app vai poder pedir o download do módulo sob demanda usando a biblioteca Play Core. Para saber mais, leia Configurar entrega condicional.

IntelliJ IDEA 2019.1

O ambiente de desenvolvimento integrado principal do Android Studio foi atualizado com as melhorias do IntelliJ IDEA até a versão 2019.1, por exemplo, personalização de temas.

A última versão do IntelliJ incluída no Android Studio foi a 2018.3.4. Para ver mais informações sobre as melhorias de outras versões do IntelliJ incluídas cumulativamente nesta versão do Android Studio, consulte as seguintes atualizações de correção de bugs:

• IntelliJ IDEA 2018.3.6
• IntelliJ IDEA 2018.3.5

Atualizações do Plug-in do Android para Gradle 3.5.0

Para ver mais informações sobre as novidades do plug-in do Android para Gradle 3.5.0, como o suporte aprimorado ao processamento incremental de anotações e testes de unidade armazenáveis em cache, consulte as notas da versão.

Colaboradores da comunidade

Agradecemos a todos os colaboradores da comunidade que nos ajudaram a descobrir bugs e outras formas de melhorar o Android Studio 3.5. Em particular, gostaríamos de agradecer às seguintes pessoas que relataram bugs P0 e P1:

3.4 (abril de 2019)

O Android Studio 3.4 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

IntelliJ IDEA 2018.3.4

O ambiente de desenvolvimento integrado principal do Android Studio foi atualizado com melhorias da versão 2018.3.4 do IntelliJ IDEA (em inglês).

Atualizações do plug-in do Android para Gradle 3.4.0

Para ver mais informações sobre as novidades do plug-in do Android para Gradle 3.4.0, consulte as notas da versão.

Nova caixa de diálogo Project Structure

A nova caixa de diálogo Project Structure (PSD, na sigla em inglês) facilita a atualização de dependências e a configuração de diferentes aspectos do projeto, como módulos, variantes de build, configurações de assinatura e variáveis de build.

Para abrir a PSD, selecione File > Project Structure na barra de menus. Você também pode abrir a PSD pressionando Ctrl+Shift+Alt+S no Windows e no Linux ou Command+; (ponto-e-vírgula) no macOS. Você pode encontrar descrições de algumas das seções novas e atualizadas da PSD abaixo.

Variáveis

A nova seção de variáveis da PSD permite criar e gerenciar variáveis de build, como as que mantêm números de versão para dependências consistentes em todo o projeto.

• Veja e edite rapidamente as variáveis de build já existentes nos scripts de compilação do Gradle do projeto.
• Adicione novas variáveis de build em um nível do projeto ou do módulo diretamente da PSD.

Módulos

Configure as propriedades que são aplicadas a todas as variantes de build em um módulo existente ou adicione novos módulos ao projeto na seção Modules. Por exemplo, é aqui que você pode configurar propriedades defaultConfig ou gerenciar configurações de assinatura.

Dependências

Inspecione e visualize cada dependência no gráfico de dependências do seu projeto, conforme resolvido pelo Gradle durante a sincronização do projeto, seguindo estas etapas:

1. No painel esquerdo da PSD, selecione Dependencies.
2. No painel Modules, selecione um módulo para inspecionar as dependências resolvidas.

3. No lado direito da PSD, abra o painel Resolved Dependencies, mostrado abaixo.

   

Você também pode pesquisar e adicionar dependências ao seu projeto rapidamente. Para isso, basta selecionar primeiro um módulo da seção Dependencies da PSD, clicar no botão (+) na seção Declared Dependencies e selecionar o tipo de dependência que você quer adicionar.

Dependendo do tipo de dependência selecionada, você verá uma caixa de diálogo semelhante à mostrada abaixo que ajuda a adicionar a dependência ao módulo.

Variantes de build

Nesta seção da PSD, você pode criar e configurar variantes de build e variações de produto para cada módulo do projeto. Você pode adicionar marcadores do manifesto e arquivos ProGuard, bem como atribuir chaves de assinatura e muito mais.

Sugestões

Veja as atualizações sugeridas para dependências do projeto e variáveis de build na seção Suggestions, como mostrado abaixo.

Novo Resource Manager

O Resource Manager é uma nova janela de ferramenta para importar, criar, gerenciar e usar recursos no app. Você pode abrir a janela da ferramenta selecionando View > Tool Windows > Resource Manager na barra de menus. O Resource Manager permite que você faça o seguinte:

• Visualizar recursos: você pode ver drawables, cores e layouts para encontrar rapidamente os recursos necessários.
• Importação em massa: você pode importar vários recursos drawable de uma só vez os arrastando e soltando na janela de ferramentas Resource Manager ou usando o assistente Import drawables. Para acessar o assistente, selecione o botão (+) no canto superior esquerdo da janela de ferramentas e Import Drawables no menu suspenso.
• Converter SVGs em objetos VectorDrawable: você pode usar o assistente Import Drawables para converter imagens SVG em objetos VectorDrawable.
• Arrastar e soltar recursos: na janela da ferramenta Resource Manager, você pode arrastar e soltar os drawables nas visualizações de design e XML do Layout Editor.
• Visualizar versões alternativas: agora você pode conferir versões alternativas dos seus recursos clicando duas vezes em um recurso na janela Tool. Essa visualização mostra as diferentes versões que você criou e os qualificadores que foram incluídos.
• Visualizações em bloco e em lista: é possível mudar a visualização dentro da janela de ferramentas para conferir os recursos organizados de maneiras diferentes.

Para saber mais, leia o guia sobre como Gerenciar recursos do app.

Verificar IDs do build ao criar perfis e depurar APKs

Quando você fornece arquivos de símbolos de depuração para as bibliotecas compartilhadas .so dentro do seu APK, o Android Studio verifica se o ID do build dos arquivos de símbolos fornecidos coincide com o ID do build das bibliotecas .so dentro do APK.

Se você criar as bibliotecas nativas do APK usando um ID de build, o Android Studio vai verificar se o ID nos arquivos de símbolo corresponde ao ID das bibliotecas nativas e rejeitar os arquivos de símbolo se não houver correspondência. Se você não usar um ID do build, o fornecimento de arquivos de símbolo incorretos poderá causar problemas na depuração.

R8 ativado por padrão

O R8 integra a simplificação, redução, ofuscação, otimização e dexação em uma única etapa, o que resulta em melhorias significativas na performance do build. O R8 foi apresentado no Plug-in do Android para Gradle 3.3.0 e agora está ativado por padrão nos projetos de biblioteca Android e em apps que usam o plug-in 3.4.0 ou mais recente.

A imagem abaixo fornece uma visão geral de alto nível do processo de compilação antes do R8.

Agora, com o R8, a simplificação, redução, ofuscação, otimização e dexação (D8) são todas concluídas em uma única etapa, conforme ilustrado abaixo.

Não se esqueça de que o R8 foi projetado para funcionar com suas regras do ProGuard. Você provavelmente não vai precisar fazer nada para se beneficiar do R8. No entanto, como essa é uma tecnologia diferente do ProGuard e é projetada especificamente para projetos Android, a redução e a otimização podem resultar na remoção de códigos que o ProGuard talvez não removesse. Nessa situação improvável, talvez seja necessário adicionar outras regras para manter esse código no resultado de build.

Se você tiver problemas ao usar o R8, leia as Perguntas frequentes de compatibilidade do R8 para conferir se há uma solução. Se nenhuma solução tiver sido documentada, informe um bug. Você pode desativar o R8 adicionando uma das seguintes linhas ao arquivo gradle.properties do projeto:

# Disables R8 for Android Library modules only.
android.enableR8.libraries = false
# Disables R8 for all modules.
android.enableR8 = false

O Navigation Editor agora oferece suporte a todos os tipos de argumentos

Agora todos os tipos de argumentos compatíveis com o componente Navigation são também compatíveis com o Navigation Editor. Para mais informações sobre tipos compatíveis, consulte Transmitir dados entre destinos.

Melhorias no Layout Editor

O painel Attributes no Layout Editor foi simplificado em uma única página com seções que você pode expandir para revelar os atributos que podem ser configurados. O painel Attributes também inclui as seguintes atualizações:

• Uma nova seção Declared Attributes lista os atributos especificados pelo arquivo de layout e permite que você adicione novos atributos rapidamente.
• Agora, o painel Attributes também apresenta indicadores ao lado de cada atributo. Esses indicadores vão ser mostrados preenchidos, quando o valor do atributo for uma referência de recurso , e vazios , quando não for.
• Atributos com erros ou avisos agora estão destacados. Os destaques em vermelho indicam erros, por exemplo, uso de valores de layout inválidos. Já os destaques em laranja indicam avisos, por exemplo, uso de valores codificados.

Nova ação da intent para importar dependências rapidamente

Se você começar a usar determinadas classes do Jetpack e do Firebase no código, uma nova ação da intent vai sugerir adicionar a dependência da biblioteca do Gradle ao projeto, caso ainda não tenha feito isso. Por exemplo, se você fizer referência à classe WorkManager sem importar primeiro a dependência android.arch.work:work-runtime necessária, uma ação da intent vai permitir que você faça isso facilmente com um clique, conforme mostrado abaixo.

Em particular, como o Jetpack reempacotou a biblioteca de suporte em pacotes distintos que são mais fáceis de gerenciar e atualizar, essa ação da intent ajuda a adicionar rapidamente apenas as dependências necessárias aos componentes do Jetpack que você quer usar.

3.3 (janeiro de 2019)

O Android Studio 3.3 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

IntelliJ IDEA 2018.2.2

O ambiente de desenvolvimento integrado principal do Android Studio foi com melhorias da versão 2018.2.2 do IntelliJ IDEA.

Atualizações do Plug-in do Android para Gradle

Para ver mais informações sobre as novidades no Plug-in do Android para Gradle, consulte as notas da versão.

Navigation Editor

O Navigation Editor permite visualizar e criar rapidamente a navegação no seu app usando o componente de arquitetura Navigation.

Para ver mais informações, consulte Implementar a navegação com o componente de arquitetura Navigation.

Excluir diretórios não usados do Android Studio

Quando você executa uma versão principal do Android Studio pela primeira vez, ela busca diretórios que contêm caches, configurações, índices e registros de versões do Android Studio para os quais uma instalação correspondente não é encontrada. A caixa de diálogo Delete Unused Android Studio Directories mostra os locais, tamanhos e horários da última modificação desses diretórios não usados e fornece uma opção para os excluir.

Estes são os diretórios que o Android Studio pode excluir:

• Linux: ~/.AndroidStudio[Preview]_X.Y_
• Mac: ~/Library/{Preferences, Caches, Logs, Application Support}/AndroidStudio[Preview]_X.Y_
• Windows: %USER%\.AndroidStudio[Preview]_X.Y_

Melhorias no lint

O lint, quando invocado pelo Gradle, é significativamente mais rápido. Projetos maiores podem esperar que o lint seja executado até quatro vezes mais rápido.

Assistente Create New Project

O assistente Create New Project está com uma nova aparência e contém atualizações que agilizam a criação de novos projetos do Android Studio.

Para ver mais informações, consulte Criar um projeto.

Atualizações dos criadores de perfil

O Android Studio 3.3 inclui atualizações para cada criador de perfil.

Melhor desempenho

Com base no feedback do usuário, o desempenho da renderização ao usar os criadores de perfil foi bastante aprimorado. Continue enviando feedback, especialmente se os problemas de desempenho persistirem.

Opções de rastreamento de alocação de memória do criador de perfil

Para melhorar a performance do app durante a criação de perfil, o Memory Profiler analisa as alocações de memória periodicamente por padrão. Se quiser, você pode mudar esse comportamento usando o menu suspenso Allocation Tracking durante o teste de dispositivos que executam o Android 8.0 (API de nível 26) ou mais recente.

Usando o menu suspenso Allocation Tracking, você pode escolher um dos seguintes modos:

• Full: captura todas as alocações de memória de objeto. Se você tem um app que aloque muitos objetos, pode ter problemas significativos de performance durante a criação de perfil.
• Sampled: captura uma amostra periódica de alocações de memória de objeto. Esse é o comportamento padrão e tem menos impacto na performance do app durante a criação de perfil. É possível que haja alguns problemas de performance em apps que alocam uma grande quantidade de objetos em um curto período.

• Off: desativa a alocação de memória. Se ainda não estiver selecionado, esse modo será ativado automaticamente durante uma gravação da CPU e, em seguida, voltará à configuração anterior quando a gravação for concluída. Você pode alterar esse comportamento na caixa de diálogo de configuração de gravação da CPU.

  O rastreamento afeta objetos Java e referências JNI.

Inspecionar dados de renderização de frames

Agora, no CPU Profiler, você pode inspecionar quanto tempo leva para seu app Java renderizar cada frame na linha de execução de IU principal e no RenderThread. Esses dados podem ser úteis ao investigar afunilamentos que causam instabilidade de IU e baixas frame rates. Por exemplo, cada frame que demora mais que os 16 ms necessários para manter um frame rate eficiente é mostrado em vermelho.

Para ver dados de renderização de frame, grave um rastro usando uma configuração que permita rastrear chamadas do sistema com a opção Trace System Calls. Depois de gravar o rastro, procure informações sobre cada frame na linha do tempo para a gravação na seção chamada FRAMES, conforme mostrado abaixo.

Para saber mais sobre como investigar e corrigir problemas de frame rate, leia Renderização lenta.

Fragmentos na linha do tempo de eventos

A linha do tempo de eventos agora mostra quando os fragmentos são anexados e desconectados. Além disso, quando você passa o mouse sobre um fragmento, uma dica mostra o status dele.

Visualizar texto formatado para payloads de conexão no Network Profiler

Anteriormente, o Network Profiler exibia apenas texto bruto de payloads de conexão. O Android Studio 3.3 agora formata alguns tipos de texto por padrão, incluindo JSON, XML e HTML. Nas guias Response e Request, clique no link View Parsed para mostrar texto formatado e clique no link View Source para mostrar o texto bruto.

Para ver mais informações, consulte Inspecionar tráfego de rede com o Network Profiler.

Download automático de componentes do SDK

Quando o projeto precisa de um componente do SDK das plataformas SDK, NDK ou CMake, o Gradle agora tenta fazer o download automático dos pacotes necessários, desde que você tenha aceitado anteriormente todos os contratos de licença relacionados usando o SDK Manager.

Para ver mais informações, consulte Download automático de pacotes ausentes com o Gradle.

Suporte a Clang-Tidy

O Android Studio agora é compatível com análise de código estático usando o Clang-Tidy para projetos que incluem código nativo. Para ativar o suporte ao Clang-Tidy, atualize seu NDK para r18 ou mais recente.

Para ativar ou reativar as inspeções, abra a caixa de diálogo Settings ou Preferences e navegue até Editor > Inspections > C/C++ > General > Clang-Tidy. Quando você selecionar essa inspeção na caixa de diálogo Settings ou Preferences, a lista de verificações Clang-Tidy ativadas e desativadas será exibida na seção Option do último painel à direita. Para ativar outras verificações (em inglês), adicione-as à lista e clique em Apply.

Para configurar o Clang-Tidy com outras opções (em inglês), clique em Configure Clang-Tidy Checks Options e inclua-as na caixa de diálogo que é aberta.

Remoção de opções para personalização de C++

As seguintes opções foram removidas da caixa de diálogo Personalizar suporte para C++:

• Exceptions Support (-fexceptions)
• Suporte a informações do tipo de momento de execução (-ftti)

Os respectivos comportamentos são ativados para todos os projetos criados pelo Android Studio.

Versão do CMake 3.10.2

O CMake versão 3.10.2 agora está incluído no SDK Manager. Observe que o Gradle ainda usa a versão 3.6.0 por padrão.

Para especificar uma versão do CMake para o Gradle usar, adicione o seguinte ao arquivo build.gradle do seu módulo:

android {
    ...
    externalNativeBuild {
        cmake {
            ...
            version "3.10.2"
        }
    }
}

Para ver mais informações sobre como configurar o CMake em build.gradle, consulte Configurar o Gradle manualmente.

Nova sintaxe “+” para especificar versões mínimas do CMake

Ao especificar uma versão do CMake no arquivo build.gradle do seu módulo principal, você pode anexar um “+” para fazer a correspondência com o comportamento do comando cmake_minimum_required().

Os Android App Bundles agora são compatíveis com Instant Apps

O Android Studio agora permite criar Android App Bundles com compatibilidade total com o Google Play Instant. Em outras palavras, agora é possível criar e implantar experiências instantâneas e de instalação com um único projeto do Android Studio e as incluir em um único Android App Bundle.

Se você estiver criando um novo projeto do Android Studio usando a caixa de diálogo Create New Project, marque a caixa ao lado Configure your project > This project will support instant apps. O Android Studio cria um novo projeto de app como normalmente faria, mas inclui as seguintes propriedades no manifesto para adicionar suporte a apps instantâneos ao módulo base do app:

<manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="true" />
    ...
</manifest>

Em seguida, você pode criar um módulo com recurso instantâneo selecionando File > New > New Module na barra de menus e Instant Dynamic Feature Module na caixa de diálogo Create New Module. Não se esqueça de que a criação desse módulo também ativa o módulo base do app para experiências instantâneas.

Para implantar o app em um dispositivo local como uma experiência instantânea, edite a configuração de execução e marque a caixa ao lado de General > Deploy as instant app.

Sincronização de projeto de variante única

Sincronizar seu projeto com a configuração do build é uma etapa importante para permitir que o Android Studio entenda como o projeto está estruturado. No entanto, esse processo pode levar muito tempo em projetos grandes. Caso seu projeto use diversas variantes de build, você pode otimizar as sincronizações dele limitando-as apenas à variante selecionada no momento.

Você precisa usar o Android Studio 3.3 ou mais recente com o Plug-in do Android para Gradle 3.3.0 ou mais recente para ativar essa otimização. Quando você atende a esses requisitos, o ambiente de desenvolvimento integrado solicita que você ative essa otimização ao sincronizar seu projeto. A otimização também é ativada por padrão em novos projetos.

Para ativar essa otimização manualmente, clique em File > Settings > Experimental > Gradle (Android Studio > Preferences > Experimental > Gradle em um Mac) e marque a caixa de seleção Only sync the active variant.

Para ver mais informações, consulte Ativar sincronização de projeto de variante única.

Fornecer feedback rápido

Se você optou por compartilhar estatísticas de uso para melhorar o Android Studio, estes dois novos ícones vão ser mostrados na barra de status, na parte de baixo da janela do ambiente de desenvolvimento integrado:

Basta clicar no ícone que melhor representa sua experiência atual com o ambiente de desenvolvimento integrado. Ao fazer isso, o ambiente de desenvolvimento integrado envia estatísticas de uso que permitem que a equipe do Android Studio entenda melhor sua opinião. Em alguns casos, por exemplo, ao indicar uma experiência negativa com o IDE, você tem a oportunidade de fornecer outro feedback.

Se ainda não tiver feito isso, ative as estatísticas de uso de compartilhamento: abra a caixa de diálogo Settings (Preferences em um Mac), navegue até Appearance & Behavior > System Settings > Data Sharing e selecione Send usage statistics to Google.

3.2 (setembro de 2018)

O Android Studio 3.2 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

Assistente de novos recursos

Um novo assistente informa você sobre as alterações mais recentes no Android Studio.

O assistente vai ser aberto quando você iniciar o Android Studio depois de uma nova instalação ou atualização se ele detectar novas informações para exibir. Também é possível abrir o assistente em Help > What's new in Android Studio.

Android Jetpack

O Android Jetpack acelera o desenvolvimento em Android com ferramentas, componentes e diretrizes que eliminam tarefas repetitivas e permitem criar apps testáveis e de alta qualidade com mais rapidez e facilidade. O Android Studio inclui as atualizações a seguir para fins de compatibilidade com o Jetpack. Para saber mais, consulte a documentação do Jetpack.

Navigation Editor

O novo Navigation Editor se integra aos componentes de navegação do Android Jetpack para fornecer uma visualização gráfica da criação da estrutura de navegação do seu app. O editor simplifica o design e a implementação da navegação entre destinos no app.

O Navigation Editor é um recurso experimental no Android Studio 3.2. Para ativar o Navigation Editor, clique em File > Settings (Android Studio > Preferences no Mac), selecione a categoria Experimental no painel esquerdo, selecione a caixa ao lado de Enable Navigation Editor e reinicie o Android Studio.

Para saber mais, leia a documentação do Navigation Editor.

Migração do AndroidX

Como parte do Jetpack, estamos migrando as Bibliotecas de Suporte do Android para uma nova biblioteca de extensões do Android usando o namespace androidx. Para ver mais informações, consulte a Visão geral do AndroidX.

O Android Studio 3.2 ajuda você nesse processo com um novo recurso de migração.

Para migrar um projeto já existente para o AndroidX, selecione Refactor > Migrate to AndroidX. Se você tiver alguma dependência do Maven que não tenha sido migrada para o namespace do AndroidX, o sistema de build do Android Studio também vai converter essas dependências do projeto automaticamente.

O plug-in do Android para Gradle fornece as seguintes sinalizações globais que você pode definir no arquivo gradle.properties:

• android.useAndroidX: quando definida como true, essa flag indica que você quer começar a usar o AndroidX a partir de agora. Se a sinalização estiver ausente, o Android Studio se comportará como se a sinalização estivesse definida como false.
• android.enableJetifier: quando definida como true, essa flag indica que você quer ter suporte de ferramenta (do plug-in Android Gradle) para converter bibliotecas de terceiros como se elas tivessem sido escritas para o AndroidX. Se a sinalização estiver ausente, o Android Studio vai se comportar como se a sinalização estivesse definida como false.

As duas sinalizações serão definidas como true quando você usar o comando Migrate to AndroidX.

Se você quiser começar a usar bibliotecas AndroidX imediatamente e não precisar converter bibliotecas de terceiros, defina a sinalização android.useAndroidX como true e a sinalização android.enableJetifier como false.

Android App Bundle

O Android App Bundle é um novo formato de upload que inclui todos os recursos e o código compilado do seu app, mas repassa a geração e a assinatura do APK para a Google Play Store.

O novo modelo de exibição de apps do Google Play, chamado de Dynamic Delivery, usa seu pacote de apps para gerar e disponibilizar APKs otimizados para a configuração do dispositivo de cada usuário, de modo que eles façam o download apenas do código e dos recursos necessários à execução do app. Você não precisa mais criar, assinar e gerenciar vários APKs, e os usuários recebem downloads menores e mais otimizados.

Além disso, é possível adicionar módulos de recursos dinâmicos ao projeto do app e incluí-los no pacote de apps. Os usuários poderão fazer o download dos recursos do app e instalá-los on demand.

Para criar um pacote, escolha Build > Build Bundle(s) / APK(s) > Build Bundle(s).

Para ver mais informações, incluindo instruções sobre como criar e analisar um Android App Bundle, consulte Android App Bundle.

Dados de amostra no Layout Editor

Muitos layouts do Android têm dados do momento da execução que podem dificultar a visualização da aparência de um layout durante o estágio de design do desenvolvimento do app. Agora é possível ver facilmente a visualização no editor de layout preenchida com dados de amostra. Quando você adiciona uma visualização, um botão é exibido abaixo da visualização na janela Design. Clique nesse botão para definir os atributos de visualização de tempo de design. É possível escolher entre uma variedade de modelos de dados de amostra e especificar o número de itens de amostra para preencher a visualização.

Para tentar usar dados de amostra, adicione um RecyclerView a um novo layout, clique no botão de atributos de tempo de design abaixo da visualização e escolha uma seleção no carrossel de modelos de dados de amostra.

Slices

Os Slices oferecem uma nova maneira de incorporar partes da funcionalidade do app em outras superfícies da interface do usuário no Android. Por exemplo, com eles, é possível mostrar a funcionalidade e o conteúdo do app nas sugestões da Pesquisa Google.

O Android Studio 3.2 tem um modelo integrado para expandir seu app com as novas APIs do Slice Provider, além de novas verificações de lint para garantir o cumprimento das práticas recomendadas ao criar Slices.

Para começar, clique com o botão direito do mouse em uma pasta de projeto e escolha New > Other > Slice Provider.

Para saber mais, incluindo como testar suas interações de Slices, leia o Guia de primeiros passos com Slices.

Kotlin 1.2.61

O Android Studio 3.2 empacota o Kotlin 1.2.61, e o novo SDK do Android integra-se melhor com o Kotlin. Para ver mais informações, consulte o Blog de desenvolvedores Android (link em inglês).

IntelliJ IDEA 2018.1.6

O ambiente de desenvolvimento integrado principal do Android Studio foi atualizado com melhorias da versão 2018.1.6 do IntelliJ IDEA.

Criadores de perfil do Android

Faça um teste com os novos recursos do Android Profiler a seguir no Android Studio 3.2.

Sessões

Agora você pode salvar dados do Profiler na forma de sessões para revisitar e inspecionar mais tarde. Os dados da sua sessão serão mantidos até que você reinicie o ambiente de desenvolvimento integrado.

Quando você grava um rastreamento de método ou capturar um heap dump, o ambiente de desenvolvimento integrado adiciona esses dados (com a atividade de rede do seu app) como uma entrada separada à sessão atual, e você pode alternar facilmente entre as gravações para comparar dados.

System Trace

No CPU Profiler, selecione a nova configuração System Trace para inspecionar a atividade da linha de execução e da CPU do sistema do seu dispositivo. Essa configuração de rastreamento é criada no systrace e é útil para investigar problemas no nível do sistema, como instabilidade de IU.

Ao usar essa configuração de rastreamento, você pode marcar visualmente rotinas de código importantes na linha do tempo do Profiler pela instrumentação do seu código C/C++ com a API de rastreamento nativo ou seu código Java com a classe Trace.

Inspecionar referências de JNI no Memory Profiler

Se você implantar seu app em um dispositivo que executa o Android 8.0 (API de nível 26) ou versão mais recente, vai ser possível inspecionar as alocações de memória para o código JNI do app usando o Memory Profiler.

Enquanto o app estiver em execução, selecione uma parte da linha do tempo que você quer inspecionar e escolha JNI heap no menu suspenso acima da lista de classes, conforme mostrado abaixo. Em seguida, vai ser possível inspecionar objetos no heap normalmente e clicar duas vezes em objetos na guia Allocation Call Stack para conferir onde as referências de JNI são alocadas e liberadas no código.

Importar, exportar e inspecionar arquivos de heap dump de memória

Agora é possível importar, exportar e inspecionar arquivos de heap dump de memória .hprof criados com o Memory Profiler.

Para importar o arquivo .hprof, clique em Start new profiler session no painel Sessions e depois em Load from file. Você vai poder inspecionar os dados no Memory Profiler como faria em qualquer outro heap dump.

Para salvar dados de heap dump para revisar mais tarde, use o botão Exportar Heap Dump à direita da entrada Heap Hump no painel Sessions. Na caixa de diálogo Export As que é exibida, salve o arquivo com a extensão de nome de arquivo .hprof.

Gravar a atividade da CPU durante a inicialização do app

Agora é possível gravar a atividade da CPU durante a inicialização do seu app da seguinte maneira:

1. Selecione Run > Edit Configurations no menu principal.
2. Na guia Criação de perfil da configuração desejada, marque a caixa ao lado de Iniciar registro de rastros de método na inicialização.
3. Selecione no menu suspenso uma configuração de registro da CPU que vai ser usada.
4. Implante o app em um dispositivo com Android 8.0 (nível 26 da API) ou uma versão mais recente selecionando Run > Profile.

Exportar rastros da CPU

Depois de gravar a atividade da CPU com o CPU Profiler, você pode exportar os dados como um arquivo .trace para os compartilhar com outras pessoas ou inspecionar mais tarde.

Faça o seguinte para exportar rastros depois de gravar a atividade da CPU:

1. Clique com o botão direito no registro que você quer exportar da linha do tempo da CPU.
2. Selecione Export trace no menu suspenso.
3. Navegue até o local onde você quer salvar o arquivo e clique em Save.

Importar e inspecionar arquivos de rastreamento da CPU

Agora você pode importar e inspecionar arquivos .trace criados com API Debug ou CPU Profiler. Atualmente, não é possível importar gravações do Rastreamento do sistema.

Para importar o arquivo de rastreamento, clique em Start new profiler session no painel Sessions e selecione Load from file. Em seguida, você pode inspecionar os dados no CPU Profiler da mesma forma que faria normalmente, com as seguintes exceções:

• A atividade da CPU não é representada ao longo da linha do tempo da CPU.
• A linha do tempo de atividades de encadeamentos indica apenas onde os dados dos rastros estão disponíveis para cada encadeamento, e não os estados reais dos encadeamentos (como em execução, em espera ou em repouso).

Gravar a atividade da CPU usando a API Debug

Agora você pode iniciar e interromper a gravação da atividade da CPU no CPU Profiler instrumentando seu app com a API Debug. Depois de implantar o app em um dispositivo, o criador de perfil começará a gravar automaticamente a atividade da CPU quando o app chamar startMethodTracing(String tracePath) e interromperá a gravação quando o app chamar stopMethodTracing(). Durante a gravação da atividade da CPU que acionou o uso dessa API, o CPU Profiler mostra a API Debug como a configuração de gravação de CPU selecionada.

Energy Profiler

O Energy Profiler mostra uma visualização do uso de energia estimado do seu app, bem como eventos do sistema que afetam o uso de energia, como wakelocks, alarmes e jobs.

O Energy Profiler é exibido como uma nova linha na parte inferior da janela Profiler durante a execução do app em um dispositivo conectado ou no Android Emulator que executa o Android 8.0 (API 26) ou versão mais recente.

Clique na linha Energy para maximizar a visualização do Energy Profiler. Posicione o ponteiro do mouse sobre uma barra na linha do tempo para ver o consumo de energia por recursos de CPU, rede e localização (GPS), bem como em eventos relevantes do sistema.

Eventos do sistema que afetam o uso de energia são indicados na linha do tempo System abaixo da linha do tempo Energy. Os detalhes dos eventos do sistema dentro do período especificado serão mostrados no painel de eventos, quando você selecionar um período na linha do tempo Energy.

Use o painel de eventos para conferir a pilha de chamadas e outros detalhes de um evento do sistema, como um wake lock. Para ir até o código responsável por um evento do sistema, clique duas vezes na entrada na pilha de chamadas.

Verificação de Lint

O Android Studio 3.2 inclui muitos recursos novos e melhorados para a verificação de lint.

As novas verificações de lint ajudam você a encontrar e identificar problemas comuns de código, desde avisos sobre possíveis problemas de usabilidade até erros de alta prioridade relacionados a possíveis vulnerabilidades de segurança.

Verificações de lint para interoperabilidade entre Java/Kotlin

Para garantir a boa interação do código Java com o Kotlin, as novas verificações de lint aplicam as práticas recomendadas descritas no Guia de interoperabilidade do Kotlin. Exemplos dessas verificações incluem procurar a presença de anotações de valores nulos, usar palavras-chave difíceis de Kotlin e posicionar parâmetros de lambda por último.

Para ativar essas verificações, clique em File > Settings (Android Studio > Preferences no Mac) para abrir a caixa de diálogo Settings, navegue até a seção Editor > Inspections > Android > Lint > Interoperability > Kotlin Interoperability e selecione as regras que você quer ativar.

Para ativar essas verificações para builds de linha de comando, adicione o seguinte ao seu arquivo build.gradle:

android {
    lintOptions {
        check 'Interoperability'
    }
}

Verificação de lint para Slices

As novas verificações de lint ajudam a garantir a criação correta de Slices. Por exemplo, as verificações de lint avisarão você se uma ação primária não for atribuída a um Slice.

Novo objetivo do Gradle

Use a nova tarefa lintFix do Gradle para aplicar todas as correções seguras sugeridas pela verificação de lint diretamente no código-fonte. Um exemplo de verificação de lint que sugere a aplicação de uma correção segura é SyntheticAccessor.

Atualizações de metadados

Vários metadados, como a verificação de transmissão de serviço, foram atualizados para que verificações de lint funcionem com o Android 9 (API de nível 28).

Aviso em caso de execução do lint em uma nova variante

O Lint agora registra com qual variante e versão um valor de referência foi registrado, além de avisar caso seja ele executado em uma variante diferente daquela criada pelo valor de referência.

Melhorias nas verificações de lint existentes

O Android Studio 3.2 inclui muitas melhorias nas verificações de lint existentes. Por exemplo, as verificações de ciclo agora se aplicam a mais tipos de recursos, e o detector de tradução agora pode encontrar traduções ausentes no editor em tempo real.

IDs de problemas mais detectáveis

Os IDs de problemas agora são mostrados em mais lugares, inclusive na janela Inspection Results. Isso facilita a localização das informações necessárias para ativar ou desativar verificações específicas usando lintOptions em build.gradle.

Para mais informações, consulte Configurar opções de lint com o Gradle.

Data Binding V2

O Data Binding V2 agora está ativado por padrão e é compatível com a V1. Isso significa que, se você tem dependências de biblioteca compiladas com a V1, pode usá-las com projetos que usam o Data Binding V2. No entanto, projetos que usam a V1 não podem consumir dependências que foram compiladas com a V2.

Simplificação no D8

No Android Studio 3.1, integramos a etapa de simplificação à ferramenta D8 como um recurso experimental, reduzindo o tempo total de compilação. No Android Studio 3.2, a simplificação com o D8 é ativada por padrão.

Novo redutor de código

O R8 é uma nova ferramenta para ofuscação e redução de código que substitui o ProGuard. Comece a usar a versão de pré-lançamento do R8 incluindo o seguinte no arquivo gradle.properties do seu projeto:

android.enableR8 = true

Mudança de ABIs padrão para vários APKs

Ao criar vários APKs voltados, cada um, para uma ABI diferente, o plug-in não gera mais APKs para as seguintes ABIs por padrão: mips, mips64 e armeabi.

Se você quiser criar APKs voltados para essas ABIs, use o NDK r16b ou anterior e especifique as ABIs no arquivo build.gradle, como mostrado abaixo:

splits {
    abi {
        include 'armeabi', 'mips', 'mips64'
        ...
    }
}

splits {
    abi {
        include("armeabi", "mips", "mips64")
        ...
    }
}

Melhoria de recursos do editor para arquivos de build do CMake

Se você usa o CMake para adicionar código C e C++ ao projeto, o Android Studio agora inclui recursos aprimorados do editor para editar os scripts de build do CMake, como estes:

• Destaque de sintaxe e preenchimento de código: o IDE destaca e sugere o preenchimento de código para comandos comuns do CMake. Além disso, você pode navegar até um arquivo clicando nele enquanto pressiona a tecla Control (Command no Mac).
• Reformatação de código: agora é possível usar a opção de reformatação de código do IntelliJ para aplicar estilos de código aos seus scripts de build do CMake.
• Refatoração segura: as ferramentas integradas de refatoração do ambiente de desenvolvimento integrado agora também conferem se você está renomeando ou excluindo os arquivos usados como referência nos scripts de build do CMake.

Navegação por arquivos de cabeçalho externos

Ao usar a janela Project nas versões anteriores do Android Studio, era possível navegar e inspecionar apenas os arquivos de cabeçalho pertencentes a bibliotecas criadas em um projeto local. Com esta versão, agora você também pode ver e inspecionar os arquivos de cabeçalho incluídos nas dependências externas da biblioteca C/C++ importadas para o projeto do app.

Se você já incluiu código e bibliotecas C/C++ no projeto, abra a janela Project no lado esquerdo do ambiente de desenvolvimento integrado, selecionando View > Tool Windows > Project no menu principal e escolha Android no menu suspenso. No diretório cpp, todos os cabeçalhos que estão dentro do escopo do seu projeto de app são organizados no nó include de cada uma das dependências da biblioteca C/C++ local, conforme mostrado abaixo.

Multidex nativa ativada por padrão

As versões anteriores do Android Studio ativavam a multidex nativa ao implantar a versão de depuração de um app em um dispositivo com API do Android nível 21 ou mais recente. Agora, se você está implantando em um dispositivo ou criando um APK para lançamento, o plug-in do Android para Gradle ativa a multidex nativa para todos os módulos com definição minSdkVersion=21 ou mais recente.

AAPT2 migrado para o repositório Maven do Google

A partir do Android Studio 3.2, a origem do AAPT2 (Android Asset Packaging Tool 2) é o repositório Maven do Google.

Para usar o AAPT2, você precisa ter uma dependência google() no seu arquivo build.gradle, conforme mostrado aqui:

buildscript {
    repositories {
        google() // here
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.2.0'
    }
}
allprojects {
    repositories {
        google() // and here
        jcenter()
    }
}

buildscript {
    repositories {
        google() // here
        jcenter()
    }
    dependencies {
        classpath("com.android.tools.build:gradle:3.2.0")
    }
}
allprojects {
    repositories {
        google() // and here
        jcenter()
    }
}

A nova versão do AAPT2 corrige muitos problemas, incluindo um melhor tratamento de caracteres não ASCII no Windows.

Remoção de configuração on demand

A preferência Configure on demand foi removida do Android Studio.

O Android Studio não transmite mais o argumento --configure-on-demand para o Gradle.

ADB Connection Assistant

O novo ADB Connection Assistant fornece instruções detalhadas para configurar e usar um dispositivo pela conexão do Android Debug Bridge (ADB).

Para iniciar o assistente, escolha Tools > Connection Assistant.

O ADB Connection Assistant fornece instruções, controles em contexto e uma lista de dispositivos conectados em uma série de páginas no painel Assistente.

Melhorias do emulador

Agora é possível salvar e carregar snapshots de um dispositivo virtual do Android (AVD, na sigla em inglês) a qualquer momento no Android Emulator, tornando rápido e fácil a tarefa de retornar um dispositivo emulado a um estado conhecido para fins de teste. Ao editar um AVD usando o AVD Manager, é possível especificar qual instantâneo do AVD vai ser carregado quando ele for iniciado.

Os controles para salvar, carregar e gerenciar snapshots do AVD agora estão na guia Snapshots na janela Extended controls do emulador.

Para ver detalhes, consulte Snapshots.

Para ver mais informações sobre o que há de novo e o que foi mudado no Emulator, consulte as notas da versão do Emulator.

3.1 (março de 2018)

O Android Studio 3.1.0 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

Programação/IDE

IntelliJ 2017.3.3

O ambiente de desenvolvimento integrado principal do Android Studio foi atualizado com melhorias da versão 2017.3.3 do IntelliJ IDEA. As melhorias incluem uma análise de fluxo de controle aprimorada para coleções e strings, inferência aprimorada de valores nulos, novas correções rápidas e muito mais.

Para ver detalhes, consulte as notas da versão do JetBrains para IntelliJ IDEA versões 2017.2 e 2017.3, bem como as notas da versão do JetBrains para atualizações de correções de bugs.

Melhorias na edição do SQL com Room

Ao usar a biblioteca de banco de dados do Room, você pode aproveitar várias melhorias para a edição do SQL:

• O preenchimento de código em uma Query compreende tabelas SQL (entidades), colunas, parâmetros de consulta, aliases, mesclas, subconsultas e cláusulas WITH.
• O destaque da sintaxe SQL agora funciona.
• Você pode clicar com o botão direito do mouse em um nome de tabela no SQL e renomeá-lo, o que também reprograma o código Java ou Kotlin correspondente (incluindo, por exemplo, o tipo de retorno da consulta). A renomeação também funciona em outra direção. Portanto, renomear uma classe ou um campo Java reprograma o código SQL correspondente.
• Os usos de SQL são mostrados ao usar Find usages. Clique com o botão direito do mouse e escolha Find usages no menu de contexto.
• Para navegar até a declaração de uma entidade SQL no código Java ou Kotlin, você pode manter a tecla Control (Command no Mac) pressionada enquanto clica na entidade.

Para ver mais informações sobre como usar o SQL com Room, consulte Salvar dados em um banco de dados local usando Room.

Atualizações na vinculação de dados

Esta atualização inclui várias melhorias na vinculação de dados:

• Agora você pode usar um objeto LiveData como um campo observável em expressões de vinculação de dados. A classe ViewDataBinding agora inclui um novo método setLifecycle() que você usa para observar objetos LiveData.

• A classe ObservableField agora pode aceitar outros objetos Observable no respectivo construtor.

• Você pode ver um novo compilador incremental para suas classes de vinculação de dados. Para saber mais detalhes sobre esse novo compilador e instruções para ativá-lo, consulte Data Binding Compiler V2.

  Veja os benefícios do novo compilador:

  • As classes ViewBinding são geradas pelo plug-in do Android para Gradle antes do compilador Java.

  • As bibliotecas mantêm as respectivas classes de vinculação geradas quando o app é compilado, em vez de serem geradas novamente a cada vez. Isso pode melhorar muito a performance de projetos com vários módulos.

Compilador e Gradle

D8 é o compilador DEX padrão

O compilador D8 agora é usado por padrão para gerar bytecode DEX.

Esse novo compilador DEX traz vários benefícios, incluindo os seguintes:

• Dexação mais rápida
• Menor uso de memória
• Melhoria na geração de código (melhor alocação de registro, tabelas de string mais inteligentes)
• Melhor experiência de depuração ao percorrer o código

Você não precisa fazer nenhuma alteração no código ou no fluxo de trabalho de desenvolvimento para ter esses benefícios, a menos que tenha desativado o compilador D8 de forma manual anteriormente. Se você definir android.enableD8 como false em gradle.properties, exclua essa sinalização ou defina-a como true:

android.enableD8=true

Para saber detalhes, consulte Novo compilador DEX.

Simplificação incremental

Para projetos que usam recursos de linguagem Java 8, a simplificação incremental é ativada por padrão, o que pode melhorar os tempos de compilação.

A simplificação converte a sintaxe leve em uma forma que o compilador pode processar com mais eficiência.

Você pode desativá-la especificando o seguinte no arquivo gradle.properties do seu projeto:

android.enableIncrementalDesugaring=false

Janela de saída simplificada

O Gradle Console foi substituído pela janela Build, que tem as guias Sync e Build.

Para saber detalhes sobre como usar a nova janela simplificada Build, consulte Monitorar o processo de compilação.

Atualizações em lote e simultaneidade de indexação

A sincronização com Gradle e os processos de indexação de IDE agora são muito mais eficientes, reduzindo o tempo perdido em muitas operações de indexação redundantes.

C++ e LLDB

Fizemos muitas melhorias na qualidade e no desempenho nas fases de programação, sincronização, compilação e depuração do desenvolvimento em C++. As melhorias incluem o seguinte:

• Se você trabalhar com projetos C++ grandes, vai notar uma melhoria significativa na redução do tempo gasto na criação de símbolos. O tempo de sincronização também é muito reduzido em projetos grandes.

• Melhoria na performance ao criar e sincronizar com o CMake pela reutilização mais agressiva dos resultados armazenados em cache.

• A adição de formatadores ("impressoras bonitas") para mais estruturas de dados em C++ torna a saída do LLDB mais fácil de ler.

• O LLDB agora funciona apenas com o Android 4.1 (API de nível 16) e versões mais recentes.

Kotlin

Atualização do Kotlin para a versão 1.2.30

O Android Studio 3.1 inclui a versão 1.2.30 do Kotlin.

Código Kotlin agora analisado com verificação de lint da linha de comando

A execução de lint da linha de comando agora analisa suas classes do Kotlin.

Para cada projeto em que você quiser executar o lint, o repositório Maven do Google precisará ser incluído no arquivo build.gradle de nível superior. O repositório Maven já está incluído nos projetos criados no Android Studio 3.0 e versões mais recentes.

Ferramentas de desempenho

Exemplos de processos C++ nativos com o CPU Profiler

O CPU Profiler agora inclui uma configuração padrão para gravar rastros de amostras das linhas de execução nativas do seu app. Para usar essa configuração, implante o app em um dispositivo com Android 8.0 (API de nível 26) ou mais recente e selecione Sampled (Native) no menu suspenso de configurações de gravação do CPU Profiler. Depois disso, grave e inspecione um rastro como faria normalmente.

Você pode mudar as configurações padrão, como o intervalo de amostragem, criando uma configuração de gravação.

Para voltar a rastrear as linhas de execução Java, selecione uma configuração Sampled (Java) ou Instrumented (Java).

Filtrar rastros de CPU, resultados de alocação de memória e heap dumps

O CPU Profiler e o Memory Profiler incluem um recurso de pesquisa que permite filtrar os resultados da gravação de um rastreamento de método, alocações de memória ou heap dump.

Para pesquisar, clique em Filter no canto superior direito do painel, digite sua consulta e pressione Enter.

Dica: você também pode abrir o campo de pesquisa pressionando Control + F (Command + F no Mac).

Na guia Flame Chart do CPU Profiler, as pilhas de chamadas que incluem métodos relacionados à sua consulta de pesquisa são destacadas e movidas para o lado esquerdo do gráfico.

Para ver mais informações sobre a filtragem por método, classe ou nome do pacote, consulte Gravar e inspecionar rastreamento de método.

Guia "Request" no Network Profiler

O Network Profiler agora inclui uma guia Request que fornece detalhes sobre pedidos de rede durante a linha do tempo selecionada. Nas versões anteriores, o Network Profiler fornecia apenas informações sobre as respostas da rede.

Visualização da linha de execução no Network Profiler

Depois de selecionar uma parte da linha do tempo no Network Profiler, você pode selecionar uma das seguintes guias para ver mais detalhes sobre a atividade da rede durante esse período:

• Connection View: oferece as mesmas informações das versões anteriores do Android Studio. Lista os arquivos enviados ou recebidos durante o período selecionado da linha do tempo em todas as linhas de execução da CPU do app. Para cada pedido, você pode inspecionar o tamanho, o tipo, o status e a duração da transmissão.
• Thread View: mostra a atividade de rede de cada uma das linhas de execução da CPU do app. Essa visualização permite que você inspecione quais linhas de execução do app são responsáveis por cada pedido de rede.

Layout Inspector

O Layout Inspector ganhou novos recursos, incluindo algumas funcionalidades fornecidas anteriormente pelas ferramentas descontinuadas Hierarchy Viewer e Pixel Perfect:

• Botões de zoom e atalhos de teclado para navegar e inspecionar layouts
• Sobreposição de grade de referência
• Capacidade de carregar uma imagem de referência e usá-la como uma sobreposição (útil para comparar seu layout com um modelo de IU)
• A opção Render subtree preview para isolar uma visualização em um layout complexo

Layout Editor

A Palette no Layout Editor recebeu muitas melhorias:

• Reorganização de categorias para visualizações e layouts
• Nova categoria Common para visualizações e layouts, em que você pode fazer adições com um comando Favorite
• Melhoria na pesquisa de visualizações e layouts
• Novos comandos para abrir a documentação de um elemento específico de visualização ou layout

Você pode usar o novo comando Convert view na Component tree ou no editor de design para converter uma visualização ou um layout em outro tipo de visualização ou layout.

Agora você pode criar restrições facilmente para itens próximos à visualização selecionada usando os novos botões Create a connection no inspetor de visualização na parte de cima da janela Attributes.

Run e Instant Run

O comportamento da opção Use same selection for future launches na caixa de diálogo Select deployment target ficou mais consistente. Quando a opção Use same selection está ativada, a caixa de diálogo Select deployment target é aberta apenas na primeira vez que você usar o comando Run até que o dispositivo selecionado não esteja mais conectado.

Ao segmentar um dispositivo com o Android 8.0 (nível 26 da API) ou mais recente, o Instant Run vai poder implantar mudanças nos recursos sem causar uma reinicialização do app. Isso é possível porque os recursos estão em um APK dividido.

Emulador

Para ver detalhes sobre as novidades e as mudanças no emulador desde o Android Studio 3.0, consulte as notas da versão do Android Emulator da versão 27.0.2 até a versão 27.1.12.

As principais melhorias incluem o seguinte:

• Inicialização rápida de instantâneos para salvar o estado do emulador e iniciar mais rapidamente, com a capacidade de usar o comando Save now para salvar um estado inicial personalizado.
• Tela do emulador sem janelas.
• Imagens do sistema para Android 8.0 (API de nível 26), Android 8.1 (API de nível 27) e Visualização do desenvolvedor do Android P.

Melhorias na interface e na experiência do usuário

Mais dicas de ferramentas, atalhos de teclado e mensagens úteis

Adicionamos dicas de ferramentas e sobreposições úteis de mensagens em muitos lugares no Android Studio.

Para ver atalhos de teclado para muitos comandos, basta manter o ponteiro do mouse sobre um botão até que a dica de ferramenta apareça.

Remoção do menu Tools > Android

O menu Tools > Android foi removido. Os comandos que estavam anteriormente nesse menu foram movidos.

• Muitos comandos foram movidos diretamente para o menu Tools.
• O comando Sync project with gradle files foi movido para o menu File.
• O comando Device Monitor foi removido, conforme descrito abaixo.

Device Monitor disponível na linha de comando

No Android Studio 3.1, o Device Monitor desempenha uma função menor do que anteriormente. Em muitos casos, a funcionalidade disponível pelo Device Monitor agora é fornecida por ferramentas novas e melhoradas.

Consulte a documentação do Device Monitor para ver instruções sobre como ele pode ser invocado na linha de comando e detalhes sobre as ferramentas que ele disponibiliza.

3.0 (outubro de 2017)

O Android Studio 3.0.0 é uma versão principal que inclui uma variedade de novos recursos e melhorias.

Usuários do macOS: se você estiver atualizando uma versão mais antiga do Android Studio, pode encontrar uma caixa de diálogo de erro de atualização que diz "Alguns conflitos foram encontrados na área de instalação". Simplesmente ignore esse erro e clique em Cancelar para continuar a instalação.

Plug-in do Android para Gradle 3.0.0

O novo plug-in do Android para Gradle inclui várias melhorias e novos recursos, mas melhora principalmente a performance do build em projetos que possuem um grande número de módulos. Ao usar o novo plug-in com esses projetos grandes, você terá o seguinte:

• Tempos de configuração do build mais rápidos devido à nova resolução de dependência atrasada.
• Resolução de dependência com reconhecimento de variantes apenas para os projetos e as variantes que você está criando.
• Tempos de compilação incrementais mais rápidos ao aplicar mudanças simples no código ou nos recursos.

Esta versão também inclui o seguinte:

• Compatibilidade com Android 8.0.
• Compatibilidade com a criação de APKs separados com base nos recursos da linguagem.
• Suporte a bibliotecas Java 8 e recursos da linguagem Java 8 (sem o compilador Jack).
• Suporte à Biblioteca de Suporte Android Test 1.0 (Android Test Utility e Android Test Orchestrator).
• Velocidades de compilação de ndk-build e cmake melhoradas.
• Melhoria na velocidade de sincronização do Gradle.
• O AAPT2 agora está ativado por padrão.
• O uso de ndkCompile agora é mais restrito. Em vez disso, você precisa migrar para o CMake ou o ndk-build para compilar o código nativo que quer empacotar no seu APK. Para saber mais, leia Migrar do ndkcompile.

Para ver mais informações sobre o que foi mudado, consulte as Notas da versão do plug-in do Android para Gradle.

Se você estiver pronto para fazer upgrade para o novo plug-in, consulte Migrar para o plug-in do Android para Gradle 3.0.0.

Compatibilidade com o Kotlin

Conforme anunciado no Google I/O 2017, a linguagem de programação Kotlin agora é oficialmente compatível com o Android. Portanto, com esta versão, o Android Studio inclui suporte à linguagem Kotlin para desenvolvimento do Android.

É possível incorporar o Kotlin ao projeto, convertendo um arquivo Java em Kotlin (clique em Code > Convert Java File to Kotlin File) ou criando um novo projeto habilitado para Kotlin usando o assistente New Project.

Para começar, leia como adicionar o Kotlin ao projeto.

Suporte a recursos da linguagem Java 8

Agora você pode usar determinados recursos da linguagem Java 8 e consumir bibliotecas criadas com o Java 8. O Jack não é mais necessário, e você precisa desativar o Jack antes de usar o suporte aprimorado com a linguagem Java 8 incorporada ao conjunto de ferramentas padrão.

Para atualizar o projeto e fazer com que ele ofereça suporte ao novo conjunto de ferramentas da linguagem Java 8, atualize a Source Compatibility e a Target Compatibility para 1.8 na caixa de diálogo Project Structure (clique em File > Project Structure). Para saber mais, leia como usar os recursos da linguagem Java 8.

Android Profiler

O novo Android Profiler substitui a ferramenta Android Monitor e fornece um novo conjunto de ferramentas para medir o uso da CPU, memória e rede do seu app em tempo real. Você pode realizar o rastreamento de método baseado em amostra para cronometrar a execução do código, capturar heap dumps, ver alocações de memória e inspecionar os detalhes de arquivos transmitidos pela rede.

Para abrir, clique em View > Tool Windows > Android Profiler (ou clique em Android Profiler na barra de ferramentas).

A linha do tempo do evento na parte de cima da janela mostra eventos de toque, pressionamentos de teclas e mudanças de atividades para que você tenha mais contexto para entender outros eventos de performance na linha do tempo.

Na linha do tempo de visão geral do Android Profiler, clique nas linhas do tempo de CPU, MEMORY ou NETWORK para acessar as ferramentas do criador de perfil correspondentes.

CPU Profiler

O CPU Profiler ajuda você a analisar o uso da linha de execução da CPU do app pelo acionamento de um rastro de CPU instrumentado ou de exemplo. Em seguida, você pode solucionar problemas de desempenho da CPU usando vários modos de visualização de dados e filtros.

Para ver mais informações, consulte o Guia do CPU Profiler.

Memory Profiler

O Memory Profiler ajuda a identificar vazamentos e rotatividade de memória que podem gerar oscilações, travamentos e até mesmo falhas no app. O componente mostra um gráfico em tempo real do uso da memória pelo app, permite capturar um heap dump, forçar coletas de lixo e rastrear alocações de memória.

Para ver mais informações, consulte o Guia do Memory Profiler.

Network Profiler

O Network Profiler permite monitorar a atividade de rede do app, inspecionar o payload de cada uma das suas solicitações de rede e vincular novamente ao código que gerou a solicitação de rede.

Para ver mais informações, consulte o Guia do Network Profiler.

Criação de perfil e depuração do APK

O Android Studio agora permite que você crie perfis e depure qualquer APK sem ter que criá-lo de um projeto do Android Studio, desde que o APK seja criado para permitir a depuração e você tenha acesso aos símbolos de depuração e aos arquivos de origem.

Para começar, clique em Profile or debug APK na tela de boas-vindas do Android Studio. Ou, se já tiver um projeto aberto, clique em File > Profile or debug APK na barra de menus. Isso mostra os arquivos APK descompactados, mas não descompila o código. Portanto, para adicionar pontos de interrupção e ver stack traces corretamente, é necessário anexar arquivos de origem Java e símbolos de depuração nativos.

Para ver mais informações, consulte Criar perfil e depurar APKs prontos.

Device File Explorer

O novo Device File Explorer permite que você inspecione o sistema de arquivos do dispositivo conectado e transfira arquivos entre o dispositivo e o computador. Isso substitui a ferramenta do sistema de arquivos disponível no DDMS.

Para abrir, clique em View > Tool Windows > Device File Explorer.

Para ver mais informações, consulte o Guia do Device File Explorer.

Compatibilidade com Instant Apps

O novo suporte com Instant Apps Android permite que você crie Instant Apps no seu projeto usando dois novos tipos de módulos: Instant App e Feature. Eles exigem a instalação do SDK de desenvolvimento de Instant Apps.

O Android Studio também inclui uma nova ação de refatoração modular para adicionar suporte ao Instant Apps em um projeto já existente. Por exemplo, se você quiser refatorar seu projeto para colocar algumas classes em um módulo de recurso Instant App, selecione as classes na janela Project e clique em Refactor > Modularize. Na caixa de diálogo exibida, selecione o módulo para onde as classes precisam ir e clique em OK.

Quando estiver pronto para testar o Instant App, você poderá criar e executar o módulo Instant App em um dispositivo conectado especificando o URL do Instant App nas opções de início da configuração de execução: selecione Run > Edit Configurations, selecione o módulo Instant App e defina o URL em Launch Options.

Para ver mais informações, consulte Instant Apps Android.

Módulos do Android Things

Novos modelos do Android Things nos assistentes New Project e New Module para começar a desenvolver dispositivos IoT baseados em Android.

Para ver mais informações, veja como criar um projeto do Android Things.

Assistente de ícones adaptáveis

O Image Asset Studio é agora compatível com drawables vetoriais e permite que você crie ícones adaptativos na tela de início para o Android 8.0 enquanto cria simultaneamente ícones tradicionais (ícones "Legacy") para dispositivos mais antigos.

Para começar, clique com o botão direito do mouse na pasta res no projeto e, em seguida, clique em New > Image Asset. Na janela Asset Studio, selecione Launcher Icons (Adaptive and Legacy) como o tipo de ícone.

Para ver mais informações, leia sobre Ícones adaptativos.

Suporte a recursos de fonte

Para o suporte a novos recursos de fonte no Android 8.0, o Android Studio inclui um seletor de recursos de fonte para agregar fontes ao app ou configurar seu projeto para fazer o download das fontes no dispositivo (quando disponíveis). Com o Layout Editor, também é possível visualizar as fontes no seu layout.

Para testar as fontes para download, confira se o dispositivo ou emulador está executando o Google Play Services v11.2.63 ou mais recente. Para ver mais informações, leia sobre Fontes para download.

Assistente de Indexação de apps do Firebase

O Firebase Assistente foi atualizado com um novo tutorial para testar a Indexação de apps. Para abrir o assistente, selecione Tools > Firebase. Em seguida, selecione App Indexing > Test App Indexing.

O tutorial inclui novos botões para testar a indexação de conteúdo público e pessoal:

• Na etapa 2, clique em Preview search results para verificar se os URLs estão sendo exibidos nos resultados da Pesquisa Google.
• Na etapa 3, clique em Check for errors para verificar se os objetos indexáveis no seu app foram adicionados ao índice de conteúdo pessoal.

Android App Links Assistant

O App Links Assistant foi atualizado com estes novos recursos:

• Adicione testes de URL a cada mapeamento de URL para ter certeza de que seus filtros de intent processam URLs reais.

  

  Você também pode definir esses testes de URL manualmente usando a tag <tools:validation> descrita abaixo.

• Crie um arquivo Digital Asset Links com a entrada de objeto adequada compatível com o Google Smart Lock e adicione a tag correspondente asset_statements <meta-data> ao arquivo de manifesto.

  

Validador de filtro de intent de URL

O Android Studio agora oferece suporte a uma tag especial no arquivo de manifesto que permite testar os URLs de filtro de intent. Essas são as mesmas tags que o App Links Assistant pode criar para você.

Para declarar um URL de teste para um filtro de intent, adicione um elemento <tools:validation> ao elemento <intent-filter> correspondente. Exemplo:

<activity ...>
    <intent-filter>
        ...
    </intent-filter>
    <tools:validation testUrl="https://www.example.com/recipe/1138" />
</activity>

Inclua também xmlns:tools="http://schemas.android.com/tools" na tag <manifest>.

Se algum dos URLs de teste não transmitir a definição do filtro de intent, um erro de lint será exibido. Esse erro ainda permite que você crie variantes de depuração, mas isso interrompe os build de lançamento.

Layout Editor

O Layout Editor foi atualizado com várias melhorias, incluindo o seguinte:

• Novo layout da barra de ferramentas e ícones.
• Layout atualizado na árvore de componentes.
• Melhoria nas inserções de visualização de arrastar e soltar.
• Novo painel de erro abaixo do editor, mostrando todos os problemas com sugestões de correção (se disponíveis).
• Várias melhorias na IU para criar com ConstraintLayout, incluindo o seguinte:
  • Novo suporte para criar barreiras.
  • Novo suporte para criar grupos: na barra de ferramentas, selecione Guidelines > Add Group (requer o ConstraintLayout 1.1.0 beta 2 ou mais recente).
  • Nova IU para criar redes: selecione várias visualizações, clique com o botão direito do mouse e selecione Chain.

Layout Inspector

O Layout Inspector inclui melhorias para facilitar a depuração de problemas com os layouts do seu app, incluindo agrupamento de propriedades em categorias comuns e nova funcionalidade de pesquisa nos painéis View Tree e Propriedades.

APK Analyzer

Agora você pode usar o APK Analyzer da linha de comando com a ferramenta apkanalyzer.

O APK Analyzer também foi atualizado com as seguintes melhorias:

• Para APKs criados com o ProGuard, você pode carregar arquivos de associação do ProGuard que adicionam recursos ao DEX Viewer, incluindo estes:
  • Nós em negrito para indicar que eles não devem ser removidos ao reduzir o código.
  • Um botão para mostrar nós que foram removidos durante o processo de redução.
  • Um botão que restaura os nomes originais dos nós na visualização em árvore que foram ofuscados pelo ProGuard.
• O DEX Viewer agora mostra o impacto do tamanho estimado de cada pacote, classe e método.
• Novas opções de filtragem na parte superior para mostrar e ocultar campos e métodos.
• Na exibição em árvore, os nós que são referências não definidas no arquivo DEX aparecem em itálico.

Para ver mais informações, consulte Analisar seu build com o APK Analyzer.

Visualização do compilador D8 DEX

O Android Studio 3.0 inclui um novo compilador DEX opcional chamado D8. Ele vai substituir o compilador DX no futuro, mas você pode optar por usar o novo compilador D8 agora.

O build de DEX afeta diretamente o tempo de compilação do app, o tamanho do arquivo .dex e a performance no momento da execução. E ao comparar o novo compilador D8 com o compilador DX atual, o D8 compila mais rapidamente e gera arquivos .dex menores, tendo a mesma ou melhor performance no momento da execução de apps.

Para testá-lo, defina o seguinte no arquivo gradle.properties do seu projeto:

android.enableD8=true

Para ver mais informações, consulte a postagem do blog sobre o compilador D8 (em inglês).

Repositório Maven do Google

O Android Studio agora usa o Repositório Maven do Google por padrão, em vez de depender do Android SDK Manager para receber atualizações da Biblioteca de Suporte do Android, do Google Play Services, do Firebase e de outras dependências. Isso torna fácil manter as bibliotecas atualizadas, especialmente ao usar um sistema de integração contínua (CI).

Todos os novos projetos agora incluem o repositório Maven do Google por padrão. Para atualizar seu projeto, adicione google() ao bloco repositories do arquivo build.gradle de nível superior:

allprojects {
    repositories {
        google()
    }
}

Saiba mais sobre o repositório Maven do Google neste link.

Outras alterações

• A depuração nativa com o Android Studio não é mais compatível com Windows de 32 bits. Optamos por nos concentrar em outras plataformas porque poucos desenvolvedores estão usando essa plataforma. Se você está usando o Windows de 32 bits e planeja a depuração do código nativo, continue usando o Android Studio 2.3.
• Upgrade do ambiente de desenvolvimento integrado de base para o IntelliJ 2017.1.2, que adiciona vários recursos novos de 2016.3 e 2017.1, como refatoração de linguagem Java 8, dicas de parâmetro, realce semântico, pontos de interrupção arrastáveis, resultados instantâneos na pesquisa e muito mais.
• Adição de muitas verificações novas de lint.
• Veja também as últimas atualizações do Android Emulator.

2.3 (março de 2017)

O Android Studio 2.3.0 é basicamente uma versão de estabilidade e correção de bug, mas também inclui uma série de novos recursos.

Novo

• O Android Studio agora pode converter arquivos PNG, BMP, JPG e GIFs estáticos para o formato WebP. WebP é um formato de arquivo de imagem do Google que oferece compactação com perdas (como JPEG) e transparência (como PNG), mas pode oferecer melhor compactação do que JPEG ou PNG. Para ver mais informações, consulte Converter imagens para WebP no Android Studio.
• O novo App Links Assistant simplifica o processo de adição de Android App Links a seu app em um assistente passo a passo. Android App Links são URLs HTTP que encaminham os usuários diretamente para conteúdo específico no seu app Android.
• O Layout Editor agora inclui suporte para dois novos recursos do ConstraintLayout:
  • Defina um tamanho de visualização com base em uma proporção.
  • Crie grupos lineares compactados, distribuídos e ponderados com cadeias de restrição.
  Para ver mais informações, consulte Criar uma IU responsiva com o ConstraintLayout.
• O Layout Editor também permite criar uma lista de atributos favoritos para que você não precise clicar em Ver todos os atributos para acessar os atributos mais usados.
• Ao adicionar um ícone do material usando a caixa de diálogo Vector Import (File > New > Vector Asset), você pode filtrar a lista de ícones disponíveis por categoria ou por nome de ícone. Para ver mais informações, consulte Como adicionar um ícone do material.
• Anotações novas e atualizadas. A nova anotação @RestrictTo para métodos, classes e pacotes permite que você restrinja uma API. A anotação @VisibleForTesting atualizada agora tem um argumento otherwise opcional que permite designar qual seria a visibilidade de um método se não houvesse a necessidade de torná-lo visível para teste. O lint usa a opção otherwise para impor a visibilidade pretendida do método.
• O novo suporte ao valor de referência de lint permite que você use um snapshot do conjunto atual de avisos do projeto como um valor de referência para futuras inspeções, de modo que apenas novos problemas sejam relatados. O snapshot do valor de referência permite que você comece a usar o lint para reprovar o build por novos problemas, sem ter que voltar e resolver todos os problemas já existentes primeiro.
• Novas verificações de lint, incluindo as seguintes:
  • Verificações SDK_INT obsoletas: o Android Studio remove o código obsoleto que verifica as versões do SDK.
  • Validação do Object Animator: o lint analisa seu código para garantir que o ObjectAnimator chame métodos válidos de referência com as assinaturas corretas e verifica se esses métodos são anotados com @Keep para evitar que o ProGuard os renomeie ou remova durante builds de lançamento.
  • Cópia de decorador de itens desnecessários: versões mais antigas da biblioteca RecyclerView não incluíam uma classe de decorador de divisor, mas uma delas era fornecida como amostra nas demonstrações de suporte. Versões recentes da biblioteca têm uma classe de decorador de divisão. O lint procura a amostra antiga e sugere substituí-la pela nova.
  • Vazamento do WifiManager: antes do Android 7.0 (API de nível 24), a inicialização de WifiManager com Context.getSystemService() poderia causar um vazamento de memória se o contexto não fosse aquele do app. O lint procura por essas inicializações e, caso não consiga determinar se o contexto é o do aplicativo, ele sugere que você use Context.getApplicationContext() para ter o contexto adequado para a inicialização.
  • Prefixo de recurso aprimorado: a verificação de lint resourcePrefix tinha muitas limitações. Agora você pode configurar seu projeto com um prefixo, como android { resourcePrefix 'my_lib' }, e o lint garante que todos os seus recursos usem esse prefixo. Você pode usar variações do nome para estilos e temas. Por exemplo, para o prefixo my_lib, é possível ter temas chamados MyLibTheme, myLibAttr, my_lib_layout e assim por diante.
  • Alternar para WebP: essa verificação identifica imagens que podem ser convertidas para o formato WebP com base na configuração minSdkVersion do projeto. Uma correção associada rápida pode converter automaticamente as imagens, ou você pode converter imagens para WebP manualmente.
  • WebP inseguro: se o projeto já inclui imagens WebP, essa verificação faz uma análise para garantir que a configuração de minSdkVersion seja alta o suficiente para aceitar as imagens incluídas. Para ver mais informações sobre o suporte a WebP no Android e no Android Studio, consulte Quais navegadores são compatíveis com o WebP de maneira nativa? e Criar imagens WebP usando o Android Studio.

Mudanças

• Um botão separado para enviar mudanças com o Instant Run: depois de implantar o app, clique em Apply Changes para enviar rapidamente mudanças incrementais para o app em execução usando Instant Run. Os botões Run e Debug sempre estarão disponíveis quando você quiser enviar as mudanças de forma confiável e forçar a reinicialização do app.
  • O Instant Run é compatível apenas com a implantação do app em um dispositivo de destino com o Android 5.0 (API de nível 21) ou mais recente.
  • O Instant Run não é mais desativado para projetos vinculados a projetos nativos externos usando o CMake ou o ndk-build. No entanto, você só pode usar o Instant Run para enviar mudanças incrementais ao código Java, não ao código nativo.
  • Cold swaps (que você pode forçar para um app em execução clicando em Run ) são agora mais confiáveis. Forçar um cold swap também corrige o problema em que as mudanças nas notificações e nas IUs de widget não eram atualizadas no dispositivo de destino.
  • Inclui otimizações que agilizam a inicialização de apps. Como essas otimizações podem afetar a criação de perfil, você precisa desativar o Instant Run temporariamente sempre que criar um perfil no app.

• Os botões AVD Manager e SDK Manager agora estão na barra de navegação simples, bem como na barra de ferramentas completa. Para usar a barra de navegação simples, clique em Ver para abrir o menu e, em seguida, confira se a Barra de navegação está selecionada e se a Barra de ferramentas não está selecionada.

  
• O depurador "Hybrid" foi renomeado para depurador "Dual".
• Na caixa de diálogo Run/Debug Configurations, em "Defaults" no painel esquerdo, os seguintes nomes de configuração de execução foram mudados sem modificações de comportamento:
  • JUnit foi alterado para Android JUnit. Se você tem um projeto que usa o JUnit, ele passa a usar as configurações de execução do Android JUnit na primeira vez que você abrir o projeto com o Android Studio. Uma caixa de diálogo aparece para informar sobre a alteração de nome.
  • Android Tests foi alterado para Android Instrumented Tests.
• O GPU Debugger foi removido do Android Studio a partir da versão 2.3. Uma versão independente e de código aberto da ferramenta agora está disponível no GitHub.
• A opção "Run/Debug" não está mais disponível quando você clica com o botão direito do mouse em um script *.gradle build.
• Todos os modelos agora usam ConstraintLayout como layout padrão.
• A paleta de widgets do Layout Editor foi reformulada.

Esta versão também inclui várias correções de bugs. Veja todas as correções de bugs no 2.3.0.

Problema conhecido: alguns fabricantes de dispositivos bloqueiam o início automático de apps depois da instalação no dispositivo. Ao implantar o app em um dispositivo físico usando o Android Studio 2.3, essa restrição interrompe o comportamento pretendido do Instant Run e gera a seguinte saída de erro: Error: Not found; no service started. Para evitar esse problema, use o emulador ou ative a inicialização automática para o app nas configurações do dispositivo. O procedimento para fazer isso é diferente para cada dispositivo, portanto, verifique as instruções do fabricante. Para saber mais sobre isso, consulte o Problema #235879.

2.2 (setembro de 2016)

Novo

• Layout Editor totalmente novo, com ferramentas customizadas compatíveis com o ConstraintLayout.
• O novo Layout Inspector permite examinar instantâneos da hierarquia de layouts enquanto o app está sendo executado no emulador ou em um dispositivo.
• Nova janela Assistant para você integrar os serviços do Firebase ao seu app.
• Nova ferramenta APK Analyzer para que você possa inspecionar o conteúdo do seu aplicativo empacotado.
• Nova ferramenta Espresso Test Recorder, atualmente em Beta, para criar testes de IU, gravando suas próprias interações.
• Novo cache de build, atualmente experimental, para acelerar a performance do build.
• Nova integração de compilação C/C++ com o CMake e o ndk-build. Compile e crie código nativo novo ou já existente em bibliotecas empacotadas no APK e depure usando o lldb. Para novos projetos, o Android Studio usa o CMake por padrão, mas também é compatível com o ndk-build para projetos já existentes. Para saber como incluir código nativo no app Android, leia Adicionar código C e C++ ao projeto. Para aprender a depurar código nativo com o lldb, consulte Depurar código nativo.
• Novo Samples Browser, para que você possa pesquisar facilmente exemplos de código do Google Android no Android Studio e iniciar o desenvolvimento de apps.
• Novo Merged Manifest Viewer para diagnosticar como o arquivo de manifesto se integra às dependências do app nas variantes de build do projeto.
• A janela Run agora contém mensagens de registro do app em execução. Observe que você pode configurar a exibição do monitor do logcat, mas não a janela Run.
• Novos recursos do Android Emulator:
  • Adição de novos controles de Virtual Sensors e Cellular > Signal Strength.
  • Adição de uma opção LTE ao controle de Cellular > Network type.
  • Foram adicionados controles deslizantes verticais simulados para percorrer os menus verticais com a roda do mouse.
• Novos recursos de configuração de execução/depuração:
  • A guia Debugger dos modelos Android App e Android Tests agora contém várias novas opções para depuração com LLDB.
  • A guia Profiling dos modelos Android App e Android Tests agora contém uma opção Capture GPU Commands para ativar o rastreamento da GPU. Você pode mostrar rastros de GPU no GPU Debugger, um recurso Beta.
  • O modelo Android Tests agora tem uma opção Firebase Test Lab Device Matrix para o Deployment Target.
  • O modelo Native Application foi descontinuado. Se você usar esse modelo em um projeto, o Android Studio vai convertê-lo automaticamente no modelo Android App.
  • O modelo Android Application foi renomeado para Android App.
• Melhoria nos recursos de instalação, configuração, performance e IU no GPU Debugger (atualmente em versão Beta).
• O Android Studio agora vem com o OpenJDK 8. Projetos já existentes ainda usam o JDK especificado em File > Project Structure > SDK Location. Você pode alternar para o uso do novo JDK incluído, clicando em File > Project Structure > SDK Location e marcando a caixa de seleção Use embedded JDK.
• Foram adicionados novos menus e botões de ajuda à IU para facilitar a localização da documentação on-line.

Mudanças

• Atualização do base do código do ambiente de desenvolvimento integrado do IntelliJ 15 para o IntelliJ 2016.1
• O Instant Run agora exige que seja instalado o SDK da plataforma correspondente ao nível da API do dispositivo de destino.
• O Instant Run será desativado automaticamente se o usuário estiver executando o app em um perfil de trabalho ou como um usuário secundário.
• Foram corrigidos muitos problemas de confiabilidade do Instant Run em que as mudanças não estavam sendo implantadas ou o app falhava:
  • Alguns recursos não foram implantados no app em execução (bug: #213454).
  • O app trava quando o usuário transita entre as sessões Instant Run e não Instant Run, em que uma classe serializável não tem serialVersionUID definido (bug: #209006).
  • As mudanças de estilo não são refletidas na execução do Instant Run (bug: #210851, link em inglês).
  • A sessão do Instant Run não é confiável e gera FileNotFoundException (bug: 213083).
  • Mudanças em drawables não refletidas até que a reconstrução completa seja executada para KitKat (bug: #21530).
  • As mudanças de recursos não são refletidas com o Instant Run quando os sourceSets personalizados contêm caminhos aninhados (bug: #219145).
  • Hot e warm swap não funcionam se a classe modificada contém anotações com valor enum (bug: #209047).
  • Mudanças nos dados de anotação não são refletidas com o Instant Run (bug: #210089).
  • O Instant Run não seleciona mudanças de código se elas são feitas fora do ambiente de desenvolvimento integrado (bug: #213205).
  • A sessão de Instant Run não é confiável devido a um token de segurança incompatível (bug: #211989).
  • Cold swap falha para dispositivos não compatíveis para executar run-as (bug: #210875, link em inglês).
  • Falha do app após a reinicialização do Instant Run (bug: 219744).
  • ClassNotFoundException observada ao alternar de Instant Run para Instant Debug (bug: #215805).
• Melhor performance da sincronização do Gradle no ambiente de desenvolvimento integrado, especialmente em projetos grandes.
• Melhoria nos tempos de compilação em builds completos e incrementais com o novo código de empacotamento do app.
• Melhoria na performance e nos recursos do compilador Jack, incluindo suporte a processadores de anotações e dexação no processo. Para saber mais, leia as Notas da versão do plug-in do Android para Gradle 2.2.0.
• Remoção da propriedade Scale AVD do AVD Manager.
• As opções da linha de comando -port e -ports do Android Emulator agora informam quais portas e número de série a instância do emulador está usando e avisa se há algum problema com os valores apresentados.
• Melhoria da caixa de diálogo Create New Class e dos modelos de arquivo correspondentes. Observação: se você tiver personalizado anteriormente os modelos de arquivo AnnotationType, Class, Enum, Interface ou Singleton, vai precisar modificar os modelos para que fiquem em conformidade com os novos. Caso contrário, você não vai poder usar os novos campos na caixa de diálogo Create New Class.
• Melhoria da interface do usuário do Vector Asset Studio e compatibilidade com arquivos Adobe Photoshop Document (PSD).
• Melhoria na interface do usuário do Image Asset Studio.
• Melhoria do seletor de recursos do Theme Editor.
• Correção de vazamentos de memória e redução do uso geral de memória no Android Studio.
• Adição de um botão Background no SDK Manager para que você possa voltar ao trabalho e instalar seus pacotes em segundo plano.
• Melhoria nos Recursos de acessibilidade, incluindo suporte a leitores de tela e navegação por teclado.
• A melhoria no Code Analysis inclui verificações de qualidade de código para uso da linguagem Java 8 e mais análise de arquivos cruzados.
• Vários ícones da barra de ferramentas foram alterados.

2.1 (abril de 2016)

As principais alterações nesta atualização são compatíveis com o desenvolvimento do Android N Preview.

A plataforma Android N adiciona suporte a recursos da linguagem Java 8, que exigem um novo compilador experimental chamado Jack. A versão mais recente do Jack é atualmente compatível apenas no Android Studio 2.1. Portanto, para usar os recursos de linguagem do Java 8, use o Android Studio 2.1 para criar o app.

Observação: o Instant Run é desativado quando você ativa o compilador Jack porque atualmente eles não compatíveis.

Embora o Android Studio 2.1 agora esteja estável, o compilador Jack ainda é experimental, e você precisa ativá-lo com a propriedade jackOptions no seu arquivo build.gradle.

Além das mudanças no suporte ao N Preview, o Android Studio 2.1 inclui pequenas correções de bug e as seguintes melhorias:

• O depurador C++ compatível com Java agora é ativado por padrão quando você está usando um dispositivo N ou emulador e seleciona o modo depurador Native na guia Debugger para sua configuração de execução/depuração.

Para outras melhorias de versão, incluindo compilação Java incremental e dexação no processo, atualize o plug-in do Android para Gradle para a versão 2.1.0.

2.0 (abril de 2016)

Observação: se você estiver desenvolvendo para a prévia para desenvolvedores N, use a versão de pré-lançamento do Android Studio 2.1. O Android Studio 2.0 não oferece suporte a todos os recursos necessários para ser a prévia N

Instant Run:

• O Android Studio agora implanta builds limpos mais rápido do que nunca. Além disso, o envio de alterações de código incremental para o emulador ou dispositivo físico é quase instantâneo. Revise suas atualizações sem reimplantar um novo build de depuração ou, em muitos casos, sem reiniciar o app.
• O Instant Run é compatível com as seguintes mudanças em um app em execução:
  • Mudanças na implementação de um método de instância ou método estático já existente.
  • Mudanças em um recurso de app existente
  • Mudanças no código estrutural, como uma assinatura de método ou um campo estático, o que exige um dispositivo de destino que execute a API de nível 21 ou mais recente.
• Leia a documentação para saber mais sobre o Instant Run.

  Observação: o Instant Run tem suporte apenas quando você implanta a variante de build de depuração, usa o plug-in do Android para Gradle versão 2.0.0 ou mais recente e configura o arquivo build.gradle no nível do módulo do app para minSdkVersion 15 ou mais recente. Para ter o melhor desempenho, configure o app para minSdkVersion 21 ou mais recente.

Novas adições ao lint:

• Inspeção de instruções switch usando inteiros anotados @IntDef para garantir que todas as constantes sejam tratadas. Para adicionar instruções ausentes com rapidez, use o menu suspenso de ações de intent e selecione Add Missing @IntDef Constants.
• Sinalizações de tentativas incorretas de usar interpolação de string para inserir números de versão no arquivo build.gradle.
• Sinalizações de classes anônimas que estendem a classe Fragment.
• Sinalizações de código nativo em locais não seguros, como as pastas res/ e asset/. Essa flag incentiva o armazenamento de código nativo na pasta libs/, que é então empacotada de forma segura na pasta data/app-lib/ do aplicativo no momento da instalação. AOSP: #169950
• Sinalizações para chamadas não seguras para Runtime.load() e System.load(). AOSP: #179980
• Encontre e remova recursos não utilizados selecionando Refactor > Remove Unused Resources na barra de menus. A detecção de recursos não utilizados agora é compatível com recursos referenciados apenas por recursos não utilizados, referências em arquivos brutos, como referências de imagens .html, e atributos tools:keep e tools:discard usados pelo redutor de recursos do Gradle, considerando conjuntos de origem inativos (como recursos usados em outras variações de build) e gerenciando adequadamente importações de campo estático.
• Verifica se referências implícitas da API são compatíveis com todas as plataformas segmentadas por minSdkVersion.
• Sinaliza o uso indevido de RecyclerView e Parcelable.
• As inspeções @IntDef, @IntRange e @Size agora também são verificadas para matrizes e varargs int.

Outras melhorias:

• Otimização para o Android Emulator 2.0, que está mais rápido do que nunca, é compatível com uma ampla variedade de dispositivos virtuais e apresenta uma grande melhora na interface de usuário. Para saber mais sobre o novo emulador, leia as notas da versão das Ferramentas do SDK.
• Melhorias no Gerenciador do Dispositivo virtual Android:
  • As imagens do sistema agora são categorizadas nas seguintes guias: Recommended, x86 e Other.
  • Em configurações avançadas, você pode ativar o suporte a vários núcleos e especificar o número de núcleos que o emulador pode usar.
  • Em configurações avançadas, você pode determinar como os gráficos são renderizados no emulador, selecionando uma das seguintes opções:
    • Hardware: use a placa de vídeo do seu computador para renderizar mais rapidamente.
    • Software: use a renderização baseada em software.
    • Auto: deixe o emulador decidir qual seria a melhor opção. Essa é a configuração padrão.
• Tempos de empacotamento AAPT melhorados especificando o destino da implementação antes da criação do app. Isso permite que o Android Studio empacote com eficiência apenas os recursos exigidos pelo dispositivo especificado.
• A integração do Cloud Test Lab foi adicionada para fornecer testes de apps on demand com a conveniência e escalabilidade de um serviço em nuvem. Saiba mais sobre como você pode usar o Cloud Test Lab com o Android Studio.
• Adição de uma visualização do novo GPU Debugger. Para gráficos elaborados, você pode se valer do código OpenGL ES para otimizar seu app ou jogo.
• Adição de teste de indexação de apps do Google Adicione suporte a URLs, indexação de apps e funcionalidade de pesquisa para direcionar mais tráfego para o app, descobrir qual conteúdo é mais usado e atrair novos usuários. Teste e valide URLs no seu app, tudo no Android Studio. Consulte Compatibilidade com URLs e indexação de apps no Android Studio.
• Atualizações da versão mais recentes do IntelliJ 15, incluindo melhorias na análise de código e desempenho. Veja O que há de novo no IntelliJ para ter uma descrição completa dos novos recursos e melhorias.
• O preenchimento automático do editor de XML agora adiciona aspas ao concluir os atributos. Para verificar se essa opção está ativada, abra a caixa de diálogo Setting ou Preferences, navegue até Editor > General > Smart Keys e marque a caixa ao lado de Add quotes for attribute value on attribute completion. Problema: 195113
• O editor de XML é agora compatível com o preenchimento de código para expressões de vinculação de dados.

Versões mais antigas