Android Studio 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 será aberto quando você iniciar o Android Studio depois de uma nova instalação ou atualização, se for detectado que há novas informações a serem exibidas. Também é possível abrir o assistente em Help > What's new in Android Studio.

Android Jetpack

O Android Jetpack ajuda a acelerar o desenvolvimento em Android com componentes, ferramentas e diretrizes que eliminam tarefas repetitivas e permitem criar apps de alta qualidade compatíveis com testes com mais rapidez e facilidade. O Android Studio inclui as atualizações a seguir para o suporte ao 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, marque 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 saber mais, 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 Maven que não tenha sido migrada para o namespace do AndroidX, o sistema de build do Android Studio também as converterá automaticamente.

O Plug-in do Android para Gradle fornece as seguintes flags 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 flag estiver ausente, o Android Studio vai se comportar como se a flag 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 flag estiver ausente, o Android Studio vai se comportar como se a flag estivesse definida como false.

As duas flags 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 flag android.useAndroidX como true e a flag android.enableJetifier como false.

Android App Bundle

O Android App Bundle é um novo formato para 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 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 os incluir no pacote de apps. Os usuários podem fazer o download dos recursos do app e os instalar on demand.

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

Para 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 de tempo de 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 ter a visualização no Layout Editor facilmente preenchida com dados de amostra. Quando você adicionar uma visualização, um botão será 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 explicativo 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 IDE 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 captura 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.

Rastreamento do sistema

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 sistema, como instabilidade de interface.

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, será possível inspecionar objetos no heap normalmente e clicar duas vezes em objetos na guia Allocation Call Stack para ver onde as referências de JNI estã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 do criador de perfil e depois selecione 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 Export Heap Dump à direita da entrada Heap Hump no painel Sessions. Na caixa de diálogo Export As que é mostrada em seguida, salve o arquivo com a extensão .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 Profiling da configuração desejada, marque a caixa ao lado de Start recording a method trace on startup.
3. Selecione no menu suspenso uma configuração de registro da CPU que vai ser usada.
4. Implante seu app em um dispositivo com Android 8.0 (nível de API 26) ou mais recente selecionando Run > Profile.

Exportar rastros da CPU

Depois de registrar a atividade da CPU com o CPU Profiler, você pode exportar os dados como um arquivo .trace para 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 vai 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 o afetam, como wakelocks, alarmes e jobs.

O Energy Profiler é mostrado como uma nova linha na parte de baixo 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 ver 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 vão avisar 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 saber mais, consulte Configurar opções de lint com o Gradle.

Vinculação de dados V2

O Data Binding V2 agora está ativado por padrão e é compatível com a V1. Isso significa que, se você tiver dependências de biblioteca compiladas com a V1, poderá 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.

Simplificar a leitura com D8

No Android Studio 3.1, integramos a etapa de simplificação de leitura à ferramenta D8 como um recurso experimental, reduzindo o tempo total de build. No Android Studio 3.2, a simplificação de leitura com 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.

Para 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")
            ...
        }
    }
    

Observação: essa mudança de comportamento também está incluída no Android Studio 3.1 RC1 e versões mais recentes.

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 ambiente de desenvolvimento integrado 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 Ctrl (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 principais externos

Ao usar a janela Project nas versões anteriores do Android Studio, era possível navegar em e inspecionar apenas os arquivos de cabeçalho pertencentes às 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á inclui código e bibliotecas C/C++ no seu 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.

Multidexação nativa ativada por padrão

As versões anteriores do Android Studio ativavam a multidexação 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ê estiver implantando em um dispositivo ou criando um APK para lançamento, o plug-in do Android para Gradle ativará a multidexação nativa para todos os módulos com definição minSdkVersion=21 ou maior.

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, verifique se você tem 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, inclusive melhora o processamento 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 oferece instruções, controles em contexto e uma lista de dispositivos conectados em uma série de páginas no painel Assistant.

Melhorias do Emulator

Agora é possível salvar e carregar snapshots de um Dispositivo virtual Android (AVD, na sigla em inglês) a qualquer momento no Android Emulator, o que facilita e agiliza a tarefa de retornar um dispositivo emulado a um estado conhecido para fins de teste. Ao editar um dispositivo virtual com o AVD Manager, é possível especificar qual snapshot do dispositivo 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 mais detalhes, consulte Snapshots.

Para saber mais sobre o que há de novo e o que foi mudado no Emulator, consulte as notas da versão do Emulator.