Novos recursos na visualização do Android Studio

O Android Studio 3.6 foi lançado para o Canal estável. Faça o download aqui.

Atualmente, o Android Studio 4.1 está nos Canais Canary e Dev. O Android Studio 4.0 está no Canal Beta.

Para ver as notícias mais recentes sobre as versões, incluindo uma lista das principais correções em cada uma, consulte também as Atualizações de versão.

Se você encontrar algum problema ao usar uma versão de pré-lançamento do Android Studio, informe-nos. Seus relatórios de bugs ajudam a melhorar o Android Studio.

Android Studio 4.1

Esta seção fornece um resumo dos novos recursos e mudanças no Android Studio 4.1.

Database Inspector

Com o Android Studio 4.1 Canary 6 e versões posteriores, é possível inspecionar, consultar e modificar os bancos de dados do app usando o novo Database Inspector. Por exemplo, você pode depurar seu app em execução modificando valores no banco de dados e testando essas mudanças no dispositivo.

Modificar valores de tabela e ver as mudanças no app em execução

Para começar, implante o app em um dispositivo que executa a API de nível 26 ou posterior e selecione View > Tool Windows > Database Inspector na barra de menus.

Se a janela Database Inspector não selecionar automaticamente o processo do app, selecione-o no menu suspenso.

Inspecionar e modificar tabelas

No painel Databases, é possível ver os bancos de dados do app e expandir um nó de banco de dados para ver as tabelas dele. Quando você clica duas vezes em uma tabela, o inspetor a abre em uma guia separada à direita, conforme mostrado na captura de tela abaixo, em que é possível inspecionar os dados, classificar por colunas ou até mesmo modificar valores à medida que o app é executado no dispositivo.

Para modificar o valor de uma célula da tabela, basta clicar duas vezes na célula, mudar o valor e pressionar Enter. Se você estiver usando a biblioteca de persistência Room e observando seus bancos de dados (por exemplo, com LiveData), essas mudanças ficarão visíveis no app em execução quase imediatamente. Caso contrário, talvez seja necessário atualizar a consulta do app do banco de dados para ver as mudanças.

Inspecionar, consultar e modificar os bancos de dados do app

Se o app fizer atualizações no banco de dados e você quiser vê-las automaticamente na janela do inspetor, marque a caixa ao lado de Live updates. Lembre-se de que, enquanto essa opção estiver ativada, a tabela no inspetor será somente leitura e não será possível modificar os valores.

Como alternativa, você pode atualizar manualmente os dados no inspector clicando em Refresh Table. Da mesma forma, se houver modificações nos esquemas de banco de dados, clique em Refresh Schema no painel Databases.

Consultar o banco de dados

Para consultar um banco de dados, clique em Run SQL no painel Databases. Isso abre uma guia New Query à direita. Se o app incluir mais de um banco de dados, selecione o banco de dados que você quer consultar usando o menu suspenso na janela da guia. No campo de texto, você pode especificar sua consulta SQLite e clicar em Run. O inspetor consulta o banco de dados do app e retorna o resultado, conforme mostrado abaixo.

Consultar o banco de dados

Se você usa a biblioteca de persistência Room, o Android Studio também fornece ações de gutter para ajudar você a executar rapidamente as consultas definidas nas anotações @Query. Enquanto o app é implantado em um dispositivo compatível e o Database Inspector está aberto no ambiente de desenvolvimento integrado, clique no botão ao lado de uma anotação @Query, conforme mostrado abaixo.

Ação de gutter em anotação de consulta em Room

O Database Inspector abre uma nova guia, executa a consulta e retorna os resultados. Se a consulta incluir parâmetros de vinculação nomeados, como :name, o Android Studio solicitará valores para cada parâmetro antes de executar a consulta.

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 posterior. Com um tamanho de amostra de 32 bytes, o Native Memory Profiler rastreia as alocações/desalocações de objetos no código nativo em um período específico e fornece as seguintes informações:

  • Allocations: uma contagem de objetos alocados por malloc() ou pelo operador new durante o período selecionado.
  • Deallocations: uma contagem de objetos desalocados por free() ou pelo operador delete durante o período selecionado.
  • Deallocations: o tamanho agregado em bytes de todas as alocações durante o período selecionado.
  • Deallocations Size: o tamanho agregado em bytes de toda a memória liberada durante o período selecionado.
  • Total Count: o valor da coluna Allocations menos o valor da coluna Deallocations.
  • Remaining Size: o valor da coluna Allocations Size menos o valor na coluna Deallocations Size.

Native Memory Profiler

Para iniciar uma gravação, clique em Record native allocations na parte superior da janela do Memory Profiler:

Botão

Quando estiver pronto para concluir a gravação, clique em Stop recording.

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 no Canary é compatível com modelos de classificação de imagem e transferência de estilo, desde que sejam aprimorados com metadados. Com o tempo, a compatibilidade será expandida para outros domínios com problemas, como detecção de objetos, segmentação de imagens e classificação de texto.

Uma ampla variedade de modelos de classificação de imagem pré-treinados é fornecida no TensorFlow Hub (link em inglês). Basta procurar e fazer o download dos formatos de modelo que mencionam "metadata". 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 será importado para o projeto e o colocado na pasta ml/. Se o diretório não existir, o Android Studio o criará para você.

Importar um modelo do TensorFlow Lite

Visualizar metadados 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

Captura de tela do visualizador de modelos do TensorFlow Lite

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

Usar o modelo no app

O visualizador de modelos fornece uma amostra de código para ajudar você a começar a usar o modelo no app.

Veja um exemplo que usa mobilenet_quant_metadata.tflite:

Kotlin

    try {
        val model: MobilenetQuantMetadata = MobilenetQuantMetadata.newInstance(this)

        // Creates a TensorImage instance from Bitmap.
        val tensorImage = TensorImage()
        tensorImage.load(bitmap)

        // Runs model inference and gets result.
        val outputs: MobilenetQuantMetadata.Outputs = model.process(tensorImage)
        val tensorLabel: TensorLabel = outputs.getProbabilityAsTensorLabel()
        val probMap = tensorLabel.mapWithFloatValue

        for ((key, value) in probMap) {
            Log.d(TAG, "label = $key, prob = $value")
        }
    } catch (e: IOException) {
        // Handles exception
    }
    

Java

    try {
        MobilenetQuantMetadata model = MobilenetQuantMetadata.newInstance(this);

        // Creates a TensorImage instance from Bitmap.
        TensorImage tensorImage = new TensorImage();
        tensorImage.load(bitmap);

        // Runs model inference and gets results.
        MobilenetQuantMetadata.Outputs outputs = model.process(tensorImage);
        TensorLabel tensorLabel = outputs.getProbabilityAsTensorLabel();
        Map<String, Float> probMap = tensorLabel.getMapWithFloatValue();

        for (Map.Entry<String, Float> entry : probMap.entrySet()) {
          Log.d(TAG, "label = " + entry.getKey() + ", prob = " + entry.getValue());
        }
    } catch (IOException e) {
       // Handles exception
    }
    

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

Problemas conhecidos e soluções alternativas

  • No momento, a compatibilidade com modelos do TensorFlow Lite para domínios com problemas que não sejam classificação de imagens e transferência de estilos é limitada. Embora a importação funcione bem, algumas entradas e/ou saídas de modelo são representadas por TensorBuffers, em vez de tipos amigáveis. Para modelos sem metadados, todas as entradas e saídas de modelo serão TensorBuffers.
  • Para oferecer compatibilidade com modelos do TensorFlow Lite maiores que 20 MB, modifique a seguinte propriedade do ambiente de desenvolvimento integrado do IntelliJ: idea.max.content.load.filesize. Veja mais detalhes nesta página (link em inglês).
  • Modelos com tipos de dados de entrada e saída diferentes de DataType.UINT8 ou DataType.FLOAT32 não são compatíveis.

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

Compatibilidade com o Jetpack Compose

O kit de ferramentas Jetpack Compose traz uma abordagem moderna para criar a IU do seu app. O kit de ferramentas também oferece todos os benefícios do Kotlin, como ajudar a escrever um código conciso e idiomático que seja totalmente interoperável com o Java.

Use a versão mais recente do Android Studio 4.1 para ter a melhor experiência de desenvolvimento com o Jetpack Compose. Isso porque, ao usar o Android Studio para desenvolver seu app com o Jetpack Compose, você pode aproveitar os recursos do editor inteligente, como os modelos em New Project e a visualização imediata da IU do Compose.

Para saber mais e começar a usar, acesse a visão geral do Jetpack Compose.

Declarações em builds de depuração

As declarações no código Java agora são ativadas ao implantar a versão de depuração do app. Como o ambiente de execução do Android não é compatível com a ativação de declarações no tempo de execução (ou seja, transmitindo o equivalente da sinalização -ea/-enableassertions para uma VM Java), as declarações no seu app não tinham efeito.

Agora, quando você cria e implanta a versão de depuração do app usando o Plug-in do Android para Gradle 4.1.0-alpha01 e versões posteriores, o compilador integrado (D8) reescreve o código para ativar as declarações no tempo de compilação, para que as verificações de declaração estejam sempre ativas.

Problemas conhecidos da versão 4.1 de pré-lançamento

Esta seção descreve os problemas conhecidos na versão do Android Studio 4.1 de pré-lançamento.

Os patches não funcionam no 4.1 Canary 2

Os patches para o Android Studio 4.1 Canary 2 estão corrompidos no momento. Para atualizar para uma versão mais recente do Android Studio 4.1, encerre o Android Studio, faça o download do pacote mais recente e instale-o.

Esse problema foi corrigido no Android Studio 4.1 Canary 3.

Erros de tempo limite no CPU Profiler

Você pode enfrentar erros "Recording failed to stop" no CPU Profiler do Android Studio ao selecionar as configurações Sample Java Methods ou Trace Java Methods. Eles costumam ser erros de tempo limite, especialmente quando é exibida a seguinte mensagem de erro no arquivo idea.log:

Wait for ART trace file timed out

Os erros de tempo limite tendem a afetar os métodos rastreados mais do que os métodos de amostra e os registros longos mais do que os registros curtos. Como solução temporária, pode ser útil tentar gravações mais curtas para ver se o erro desaparece.

Se você tiver problemas de tempo limite com o Profiler, registre um bug que inclua a marca/modelo de seus dispositivos e entradas relevantes de idea.log e logcat.

Erros de controle de versões do Git no ambiente de desenvolvimento integrado

As operações que exigem autenticação no controle de versões do Git são interrompidas no ambiente de desenvolvimento integrado do Android Studio 4.1 Canary 1.

Para corrigir esse problema, faça upgrade para o Android Studio 4.1 Canary 2.

Android Studio 4.0

Esta seção fornece um resumo dos novos recursos e mudanças no Android Studio 4.0.

Upgrades na IU do CPU Profiler

Upgrades de IU de rastreamento do sistema

Com base no seu feedback, a IU do CPU Profiler foi revisada para fornecer um fluxo de trabalho mais intuitivo. As principais mudanças incluem:

  • Os registros da CPU agora são separados da linha do tempo do principal criador de perfil para facilitar a análise. Os dados registrados são organizados em grupos no lado esquerdo da janela Profiler. Você pode mover os grupos para cima e para baixo para reorganizar a lista clicando no ícone de opções ícone de opções no criador de perfil no canto superior direito da janela ou arrastando e soltando itens individuais dentro de 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 da atividade (incluindo métodos, funções e eventos).
  • 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 os registros de rastreamento do sistema e recolhidas por padrão para outros tipos de gravação. Clique duas vezes nos nomes das linhas de execução para expandi-las ou recolhê-las.
  • A IU de rastreamento do sistema, como mostrado na captura de tela acima, também foi aprimorada. Por exemplo, os eventos agora são coloridos de forma exclusiva para facilitar a diferenciação.

Esse recurso ainda está em andamento. Por isso, continue enviando feedback.

Remoção do recurso de processamento de anotações separado

A possibilidade de separar o processamento de anotações em uma tarefa dedicada foi removida. Essa opção era usada para manter a compilação Java incremental quando processadores de anotações não incrementais eram usados em projetos somente Java. A opção era ativada configurando android.enableSeparateAnnotationProcessing como true no arquivo gradle.properties, o que não funciona mais.

Em vez disso, você precisa passar a usar processadores de anotações incrementais para melhorar o desempenho de compilação.

Janela Build Speed

Ao usar o Android Studio 4.0 Canary 3 com o Plug-in do Android para Gradle 4.0.0-alpha03 e mais recentes, a janela Build Speed ajuda você a entender e diagnosticar problemas no processo de compilação, como otimizações desativadas e tarefas configuradas incorretamente. Ao usar o Android Studio 4.0 Canary 3 e o Plug-in do Android para Gradle 4.0.0-alpha03 e mais recentes, você pode abrir a janela Build Speed da seguinte forma:

  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 Speed de uma das seguintes maneiras:
    • Depois que o Android Studio concluir a criação do seu projeto, clique na guia Build Speed.
    • Depois que o Android Studio concluir a criação do seu projeto, clique no link no lado direito da janela Build Output.

A janela Build Speed 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 ajudar você a entender o impacto de cada tarefa. Você também pode ver detalhes sobre os avisos expandindo o nó Warnings.

Gráfico Build Speed

Quais tarefas determinam a duração de compilação?

O Gradle determina a execução de tarefas por interdependências de tarefas, estrutura do projeto e carga de CPU e executa as tarefas de forma sequencial ou em paralelo. Para determinado build, a janela Build Speed destaca o conjunto de tarefas executadas em sequência que determinaram a duração de compilação atual. Solucionar as ineficiências nessas tarefas destacadas é o melhor ponto de partida para reduzir o tempo de compilação total.

Lembre-se de que você poderá ver um conjunto diferente de tarefas determinando a duração de cada build que executar. Por exemplo, se você fizer mudanças na configuração, executar um build com um conjunto diferente de tarefas (como um build incremental) ou com restrições diferentes (como carga maior sobre a CPU), a janela Build Speed poderá destacar um conjunto diferente de tarefas que mais afetaram a duração desse build. Devido a essa variabilidade, convém usar a janela Build Speed em várias versões para reduzir de forma consistente a duração de compilação.

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: se atualiza à medida que as visualizações do dispositivo mudam.

Hierarquia de layout dinâmica

  • 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.

Pilha de resolução de valores de propriedades

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

Layout Inspector: visualização em 3D

Você pode usar o Live Layout Inspector somente ao implantar seu aplicativo em dispositivos que executam a API de nível 29 ou mais recentes. Para ativar o recurso, navegue até File > Settings > Experimental e marque a caixa ao lado de Enable Live Layout Inspector.

Multi Preview

A Multi Preview é uma ferramenta visual para ver simultaneamente layouts em diferentes dispositivos e configurações, o que pode ajudar a detectar possíveis problemas nos seus layouts.

Você pode acessar esse recurso clicando na guia Multi Preview no canto superior direito da janela do IDE:

Guia

Você pode escolher entre dois conjuntos de configurações diferentes: dispositivos Pixel e localidades de projeto. Para alternar entre esses conjuntos de configurações, selecione no menu suspenso na parte superior da janela Multi Preview:

Demonstração da Multi Preview

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

O Android Studio agora é compatível com o uso de diversas APIs da linguagem Java 8 sem a necessidade de um nível mínimo de API para seu app.

Por meio de um processo chamado desugaring (simplificação), o compilador DEX, D8, no Android Studio 3.0 e mais recentes, já fornecia compatibilidade significativa com recursos da linguagem Java 8, como expressões lambda, métodos de interface padrão e try-with-resources, entre outros. No Android Studio 4.0, o mecanismo de simplificação foi estendido para ser capaz de 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 é compatível com esta 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 compatibilidade com 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 seu app. O processo de simplificação reescreve o código do seu app para usar essa biblioteca no momento da execução.

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

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.5'
    }
    

Informe-nos se você tiver problemas ou se tiver outras APIs a que queira oferecer compatibilidade preenchendo informações de bugs no bug tracker (link em inglês).

Compatibilidade com arquivos de script DSL do Kotlin

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

Recursos do editor inteligente para regras do ProGuard

Agora, o Android Studio oferece recursos de edição inteligente quando você abre arquivos de regras do ProGuard, 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.

Recursos do editor inteligente para editar arquivos de regras do ProGuard

Novo editor de movimento

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

O editor de movimento fornece uma interface simples para processar elementos da biblioteca MotionLayout, que serve como base para a animação em apps para 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 editor de movimento pode gerar esse XML para você, oferecendo compatibilidade com estados de início e fim, frames-chave, transições e linhas do tempo.

Para começar a usar o editor de movimento:

  1. Crie um ConstraintLayout.
  2. Clique com o botão direito do mouse na visualização no Layout Editor.
  3. Clique em Convert to MotionLayout, conforme mostrado abaixo.

Depois que o Android Studio converte o ConstraintLayout para MotionLayout, um arquivo Motion Scene também é adicionado ao diretório que contém o XML.

O MotionLayout se torna seu layout raiz e aparece na IU do editor de movimento. O layout já inclui um ConstraintSet inicial, um ConstraintSet final e uma transição do início ao fim.

Você pode usar o gráfico de visão geral para selecionar ConstraintSet ou Transition, bem como componentes do painel de seleção.

Em seguida, você pode editar as restrições e os atributos do ConstraintSet inicial ou final da mesma forma que editaria ConstraintLayout.

Se você quiser criar mais elementos para seu gráfico, poderá usar os ícones de criação para adicionar rapidamente gestos ConstraintSet, Transition ou OnClick/OnSwipe.

Para adicionar um frame-chave, clique na seta Transition:

Em seguida, no painel de linha do tempo Transition, clique no canto superior direito e selecione KeyPosition:

Essa ação abre uma caixa de diálogo em que você pode definir atributos para o frame-chave.

Você também pode adicionar gerenciadores OnClick e OnSwipe à transição no painel de atributos.

Essa ação abre uma caixa de diálogo em que você pode definir atributos do clique, como componentes de destino e direção de arraste.

O editor de movimento é compatível com a visualização de animações na superfície de design. Quando uma animação for selecionada, clique em Play acima da linha do tempo para visualizar a animação.

Novidades no Plug-in do Android para Gradle 4.0.0

Esta seção descreve novos recursos e mudanças de comportamento no Plug-in do Android para Gradle 4.0.0.

Novas opções para ativar ou desativar recursos de compilação

O Plug-in do Android para Gradle 4.0.0-alpha05 apresenta uma nova maneira de controlar quais recursos de compilação você quer ativar e desativar, como "View Binding", "Data Binding" e "Jetpack Compose". Quando novos recursos são adicionados, eles ficam desativados por padrão. Você pode usar o bloco buildFeatures para ativar apenas os recursos que quiser, e isso ajuda a otimizar o desempenho de compilação do projeto. Você pode definir as opções para cada módulo no arquivo build.gradle do módulo da seguinte maneira:

    android {
        // The default value for each feature is shown below. You can change the value to
        // override the default behavior.
        buildFeatures {
            // Determines whether to generate a BuildConfig class.
            buildConfig = true
            // Determines whether to support View Binding.
            // Note that the viewBinding.enabled property is now deprecated.
            viewBinding = false
            // Determines whether to support Data Binding.
            // Note that the dataBinding.enabled property is now deprecated.
            dataBinding = false
            // Determines whether to generate binder classes for your AIDL files.
            aidl = true
            // Determines whether to support RenderScript.
            renderScript = true
            // Determines whether to support injecting custom variables into the module's R class.
            resValues = true
            // Determines whether to support shader AOT compilation.
            shaders = true
        }
    }
    

Também pode especificar a configuração padrão para esses recursos em todos os módulos de um projeto incluindo uma ou mais das seguintes opções no arquivo gradle.properties do seu projeto, como mostrado abaixo. Lembre-se de que também é possível usar o bloco buildFeatures no arquivo build.gradle de cada módulo para substituir essas configurações padrão do projeto.

android.defaults.buildfeatures.buildconfig=true
    android.defaults.buildfeatures.aidl=true
    android.defaults.buildfeatures.renderscript=true
    android.defaults.buildfeatures.resvalues=true
    android.defaults.buildfeatures.shaders=true
    

Dependências de recurso sobre recurso

Nas versões anteriores do Plug-in do Android para Gradle, todos os módulos de recursos dinâmicos podiam depender apenas do módulo básico do app. Ao usar o Plug-in do Android para Gradle 4.0.0, você pode incluir um módulo de recurso 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.

Dependências de recurso sobre recurso

O recurso dinâmico :video depende do recurso :camera, que depende do módulo base :app.

Isso significa que, quando o app solicita o download de um módulo de recurso dinâmico, ele também faz o download de outros módulos de recursos de que depende. Depois de criar módulos de recursos dinâmicos 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 dynamic feature modules must declare a dependency
        // on the base module.
        implementation project(':app')
        // Declares that this module also depends on the 'camera'
        // dynamic feature module.
        implementation project(':camera')
        ...
    }
    

Além disso, ative o recurso de dependência de recurso sobre recurso no Android Studio (para oferecer compatibilidade com o recurso ao editar a configuração de execução, por exemplo) clicando em Help > Edit Custom VM Options na barra de menus e incluindo o seguinte:

-Drundebug.feature.on.feature=true
    

Os Plug-ins do Android para Gradle "feature" e "instantapp" foram removidos

O Plug-in do Android para Gradle 3.6.0 suspendeu o uso dos plug-ins Feature (com.android.feature) e Instant App (com.android.instantapp) em favor do uso do plug-in Dynamic Feature (com.android.dynamic-feature) para criar e empacotar seus apps instantâneos usando o Android App Bundles.

No Plug-in do Android para Gradle 4.0.0-alpha01 e mais recentes, esses plug-ins suspensos foram totalmente removidos. Para usar o Plug-in do Android para Gradle mais recente, você precisa migrar seu app instantâneo para o Android App Bundles. Ao migrar seus apps instantâneos, você pode aproveitar os benefícios dos pacotes de apps e simplificar o design modular do seu aplicativo.

Metadados de dependências

Quando você cria seu app usando o Plug-in do Android para Gradle 4.0.0-beta02 e posterior, 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 compilação 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, desative isso incluindo 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
        }
    }
    

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 fragmento 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.

O assistente da galeria de fragmentos.

O assistente da galeria de fragmentos.

Importar bibliotecas nativas das dependências de AAR

A partir do Plug-in do Android para Gradle 4.0 Canary 9, é possível importar bibliotecas C/C++ das dependências de AAR do app. Quando você segue as etapas de configuração descritas abaixo, o Gradle disponibiliza automaticamente essas bibliotecas nativas para uso com o sistema de compilação nativo externo, como o CMake. O Gradle só disponibiliza essas bibliotecas para seu build. Você ainda precisa configurar scripts de compilação para usá-las.

As bibliotecas são exportadas usando o formato de pacote Prefab.

Cada dependência pode expor, no máximo, um pacote Prefab, que compreende um ou mais módulos. Um módulo Prefab é uma única biblioteca, que pode ser compartilhada, estática ou apenas de cabeçalho.

Normalmente, o nome do pacote corresponde ao nome do artefato Maven, e o nome do módulo corresponde ao nome da biblioteca, mas nem sempre isso ocorre. Como você precisa saber o nome do pacote e do módulo das bibliotecas, talvez seja necessário consultar a documentação da dependência para determiná-los.

Configurar o sistema de compilação nativo externo

Para ver as etapas a serem seguidas, clique no sistema de compilação nativo externo que você planeja usar.

As dependências nativas incluídas em um AAR são expostas ao projeto do CMake por meio de CMAKE_FIND_ROOT_PATH. Esse valor será definido automaticamente pelo Gradle quando o CMake for invocado. Portanto, se o build modificar essa variável, anexe-a em vez de atribuí-la.

Cada dependência expõe um pacote config-file ao build do CMake, que você importa com o comando find_package (links em inglês). Esse comando procura por pacotes config-file que correspondam ao nome do pacote e à versão fornecidos e expõe os destinos que ele define para serem usados no build. Por exemplo, se o aplicativo definir libapp.so e usar curl, você terá que incluir o seguinte no arquivo CMakeLists.txt:

add_library(app SHARED app.cpp)

    # Add these two lines.
    find_package(curl REQUIRED CONFIG)
    target_link_libraries(app curl::curl)
    

Agora, você pode especificar #include "curl/curl.h" em app.cpp. Quando você cria seu projeto, o sistema de compilação nativo externo vincula automaticamente libapp.so a libcurl.so e pacotes libcurl.so no APK ou no pacote de apps.

Problemas conhecidos da versão 4.0 de pré-lançamento

Esta seção descreve os problemas conhecidos no Android Studio 4.0 de pré-lançamento.

O Build Analyzer está desativado na versão Beta 4

O Build Analyzer está desativado no Android Studio 4.0 Beta 4. Ele será reativado na versão Beta 5.

Erros de tempo limite no CPU Profiler

Você pode enfrentar erros "Recording failed to stop" no CPU Profiler do Android Studio ao selecionar as configurações Sample Java Methods ou Trace Java Methods. Eles costumam ser erros de tempo limite, especialmente quando é exibida a seguinte mensagem de erro no arquivo idea.log:

Wait for ART trace file timed out

Os erros de tempo limite tendem a afetar os métodos rastreados mais do que os métodos de amostra e os registros longos mais do que os registros curtos. Como solução temporária, pode ser útil tentar gravações mais curtas para ver se o erro desaparece.

Se você tiver problemas de tempo limite com o Profiler, registre um bug que inclua a marca/modelo de seus dispositivos e entradas relevantes de idea.log e logcat.

Os patches não funcionam no 4.0 Beta 2

Os patches para o Android Studio 4.0 Beta 2 estão corrompidos no momento. Para atualizar para uma versão mais recente do Android Studio 4.0, encerre o Android Studio, faça o download do pacote mais recente e instale-o.

Esse problema foi corrigido no Android Studio 4.0 Beta 3.

Erros de controle de versões do Git no ambiente de desenvolvimento integrado

As operações que exigem autenticação no controle de versões do Git são interrompidas no ambiente de desenvolvimento integrado do Android Studio 4.0 Beta 1.

Para corrigir esse problema, faça upgrade para o Android Studio 4.0 Beta 2 ou mais recente.

Os botões Run, Debug e Profile estão ausentes da barra de ferramentas

Se você personalizou o grupo de botões de ação Run/Debug, por exemplo, modificando as opções em Appearance & Behavior > Menus and Toolbars na janela Settings ou Preferences, esses botões de ação podem desaparecer da barra de ferramentas após a reinicialização do ambiente de desenvolvimento integrado. Esse é um problema conhecido na versão do IntelliJ em que o Android Studio 4.0 é compilado (consulte o problema IDEA-228450, em inglês).

Para resolver esse problema, reverta as personalizações feitas nesses botões da seguinte maneira:

  1. Selecione File > Settings (ou Android Studio > Preferences no macOS).
  2. Na parte esquerda da janela, navegue até Appearance & Behavior > Menus and Toolbars.
  3. No lado direito da janela, navegue até Main Toolbar > Toolbar Run Actions e selecione Run/Debug.
  4. Próximo à parte superior da janela, clique em Revert e selecione Restore Run/Debug.
  5. Clique em OK. Agora você verá os botões que estavam ausentes na barra de ferramentas.

Patches indisponíveis para o Canary 5

Nenhum patch do Android Studio 4.0 Canary 5 está disponível para versões do Android Studio 4.0 Canary lançadas anteriormente. Para instalar o Android Studio 4.0 Canary 5, faça o download na página de downloads do Android Studio.

Profilers e Live Layout Inspector no Canary 5

A partir do Android Studio 4.0 Canary 5, o Live Layout Inspector e os Profilers não funcionarão corretamente no Windows, causando a seguinte mensagem de erro:

    transfer error: couldn't create file: Read-only file system.
    

Para corrigir esse problema, faça upgrade para o Android Studio 4.0 Canary 7 ou mais recente.

Repositório Maven do Kotlin ausente

Se você estiver usando o Android Studio 4.0 Canary 4 ou versão anterior, talvez veja a seguinte mensagem de erro:

Application build has failed with an error (Could not find org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.3.60-eap-25)
    

Para resolver esse problema, atualize para o Android Studio 4.0 Canary 5 ou mais recente.

IllegalStateException ao implantar apps com dependências nativas

Se o app incluir dependências nativas e tiver androidParallelJsonGen=true (padrão), você encontrará uma exceção IllegalStateException ao implantar o app pelo Android Studio. Para contornar esse problema, defina android.enableParallelJsonGen=false no arquivo gradle.properties do projeto. Para ver mais detalhes, consulte o problema 149575364 (link em inglês).

Problemas que incluem dependências nativas

No momento, o Plug-in do Android para Gradle usa como padrão uma versão mais antiga do Prefab com alguns problemas conhecidos:

  • Os caminhos para as bibliotecas têm escape incorreto no Windows.
  • O plug-in do CMake exporta bibliotecas estáticas incorretamente.
  • Combinações STL válidas podem ser rejeitadas incorretamente.

A versão mais recente do Prefab tem correções para esses problemas. Para usar a versão mais recente do Prefab, defina android.prefabVersion como 1.0.0-alpha6 ou posterior no arquivo gradle.properties do projeto.