Android Dev Summit, October 23-24: two days of technical content, directly from the Android team. Sign-up for livestream updates.

Compilar e executar o app

O Android Studio configura novos projetos para implantar no Android Emulator ou em um dispositivo conectado com apenas alguns cliques. Depois que seu app for instalado, o Instant Run permitirá que você faça alterações no código sem criar um novo APK.

Para criar e executar seu app, selecione Run > Run na barra de menus (ou clique em Run na barra de ferramentas). Se estiver executando o app pela primeira vez, o Android Studio solicitará que você selecione um destino de implantação, conforme mostrado na Figura 1. Selecione um dispositivo para instalar e executar seu app.

Figura 1. A caixa de diálogo Select Deployment Target mostra os dispositivos disponíveis.

Se a caixa de diálogo mostrar a mensagem "No USB devices or running emulators detected", será necessário configurar e conectar o dispositivo ou iniciar um emulador clicando em um dispositivo listado em Available Virtual Devices. Se não houver dispositivos virtuais listados, clique em Create New Virtual Device e siga o assistente de configuração do dispositivo virtual (consulte Criar e gerenciar dispositivos virtuais).

Para exibir a caixa de diálogo Select Deployment Target, desmarque Use same device for future launches ou pare o app com Run > Stop app ou Stop e, em seguida, inicie-o novamente.

Observação: também é possível implantar seu app no modo de depuração clicando em Debug . Executar o app no modo de depuração permite que você defina pontos de interrupção no código, examine variáveis e avalie expressões no momento execução, além de executar ferramentas de depuração. Para saber mais, consulte Depurar seu app.

Alterar a configuração de execução/depuração

Quando você executa o app pela primeira vez, o Android Studio usa uma configuração de execução padrão. A configuração de execução especifica se o app será implantado a partir de um APK ou de um Android App Bundle, o módulo a ser executado, o pacote a ser implantado, a atividade a ser iniciada, o dispositivo de destino, as configurações do emulador, as opções do logcat e muito mais.

A configuração padrão de execução/depuração cria um APK, inicia a atividade de projeto padrão e usa a caixa de diálogo Select Deployment Target para seleção de dispositivo de destino. Se as configurações padrão não forem adequadas ao seu projeto ou módulo, você pode personalizar as configurações de execução/depuração ou mesmo criar novas configurações nos níveis de projeto, padrão e módulo. Para editar uma configuração de execução/depuração, selecione Run > Edit Configurations. Para mais informações, consulte Criar e editar configurações de execução/depuração.

Alterar a variante de compilação

Por padrão, o Android Studio cria a versão de depuração do app destinada apenas para uso durante o desenvolvimento, quando você clica em Executar.

Para alterar a variante de compilação que o Android Studio usa, selecione Build > Select Build Variant na barra de menus (ou clique em Build Variants na barra de janelas de ferramentas) e, em seguida, selecione uma variante de compilação no menu suspenso. Por padrão, novos projetos são configurados com duas variantes de compilação: uma variante de depuração e outra de lançamento. É necessário compilar a versão de lançamento para preparar o app para lançamento para o público.

Para criar outras variações do app, cada uma com recursos ou requisitos de dispositivo diferentes, você pode Configurar variações de compilação.

Criar o projeto

O botão Run cria e implanta o app em um dispositivo. No entanto, se quiser criar seu app para compartilhar ou fazer upload para o Google Play, você precisará usar uma das opções no menu Build de modo a compilar partes do projeto ou ele todo. Antes de selecionar qualquer uma das opções de compilação listadas na tabela 1, primeiro selecione a variante de compilação a ser usada.

Tabela 1. Opções de compilação no menu Build.

Item de menu Descrição
Make Module Compila no módulo selecionado todos os arquivos de origem que foram modificados desde a última compilação, assim como todos os módulos dos quais o módulo selecionado depende recursivamente. A compilação inclui arquivos de origem dependente e quaisquer tarefas associadas. Você pode selecionar o módulo a ser compilado selecionando o nome do módulo ou um dos arquivos dele na janela Project. Esse comando não gera um APK.
Make Project Faz todos os módulos.
Clean Project Exclui todos os arquivos de compilação intermediários/armazenados em cache.
Rebuild Project Executa o Clean Project para a variante de compilação selecionada e produz um APK.
Build Bundle(s) / APK(s) > Build APK(s)

Cria um APK de todos os módulos no projeto atual para a variante selecionada. Quando a compilação for concluída, uma notificação de confirmação será exibida, fornecendo um link para o arquivo APK e um link para analisá-lo no APK Analyzer.

Se a variante de compilação selecionada for um tipo de depuração, o APK será assinado com uma chave de depuração e estará pronto para ser instalado. Se você selecionou uma variante de versão, o APK não estará assinado por padrão, e você precisará assinar o APK manualmente. Como alternativa, é possível selecionar Build > Generate Signed Bundle / APK na barra de menus.

O Android Studio salva os APKs criados em project-name/module-name/build/outputs/apk/.

Build Bundle(s) / APK(s) > Build Bundle(s)

Cria um Android APP Bundle de todos os módulos no projeto atual para a variante selecionada. Quando a compilação for concluída, uma notificação de confirmação será exibida, fornecendo um link para o pacote de apps e um link para análise no APK Analyzer.

Se a variante de compilação selecionada for um tipo de depuração, o pacote de apps será assinado com uma chave de depuração e você poderá usar o bundletool para implantar seu app do pacote de apps em um dispositivo conectado. Se você selecionou uma variante de versão, o pacote de apps não estará assinado por padrão e você precisará assiná-lo manualmente usando jarsigner. Como alternativa, selecione Build > Generate Signed Bundle / APK na barra de menus.

O Android Studio salva os APKs criados em project-name/module-name/build/outputs/bundle/.

Generate Signed Bundle / APK Abre uma caixa de diálogo com um assistente para uma nova configuração de assinatura e cria um APK ou um pacote de apps assinado. Você precisa assinar seu app com uma chave de versão para poder fazer upload para o Play Console. Se quiser mais informações sobre a assinatura de apps, consulte Assinar seu app.

Observação: o botão Run cria um APK com testOnly="true", o que significa que o APK só pode ser instalado via adb (que o Android Studio usa). Se você quiser um APK depurável que as pessoas possam instalar sem o adb, selecione a variante de depuração e clique em Build Bundle(s) / APK(s) > Build APK(s).

Para mais detalhes sobre as tarefas que o Gradle executa para cada comando, abra a janela Build conforme descrito na próxima seção. Para mais informações sobre o Gradle e o processo de compilação, consulte Configurar sua compilação.

Monitorar o processo de compilação

Veja detalhes sobre o processo de compilação clicando em View > Tool Windows > Build (ou clicando em Build na barra da janela de ferramentas). A janela exibe as tarefas que o Gradle executa para compilar seu app, conforme mostrado na Figura 2.

Figura 2. A janela de saída "Build" no Android Studio.

  1. Guia Build: exibe as tarefas que o Gradle executa como uma árvore, onde cada nó representa uma fase de compilação ou um grupo de dependências de tarefas. Se você receber erros de tempo de criação ou tempo de compilação, inspecione a árvore e selecione um elemento para ler a saída do erro, conforme mostrado na Figura 3 abaixo.

    Figura 3. Inspecione a janela de saída "Build" em busca de mensagens de erro.

  2. Guia Sync: exibe as tarefas que o Gradle executa para sincronizar com os arquivos de projeto. Assim como na guia Build, se você encontrar um erro de sincronização, selecione elementos na árvore para ver mais informações sobre o erro.
  3. Restart: executa a mesma ação que selecionar Build > Make Project, gerando arquivos intermediários de compilação para todos os módulos do projeto.
  4. Toggle view: alterna entre a exibição da execução da tarefa como uma árvore gráfica e a exibição de uma saída de texto mais detalhada do Gradle. Essa é a mesma saída que você vê na janela Gradle Console no Android Studio 3.0 e versões anteriores.

Se suas variantes de compilação usam variações de produto, o Gradle também invoca tarefas para compilar essas variações. Para ver a lista de todas as tarefas de compilação disponíveis, clique em View > Tool Windows > Gradle (ou clique em Gradle na barra da janela de ferramentas).

Se ocorrer um erro durante o processo de compilação, o Gradle pode recomendar algumas opções de linha de comando para ajudar você a resolver o problema, como --stacktrace ou --debug. Para usar opções de linha de comando com seu processo de compilação:

  1. Abra a caixa de diálogo Settings ou Preferences.
    • No Windows ou no Linux, selecione File > Settings na barra de menus.
    • No Mac OSX, selecione Android Studio > Preferences na barra de menus.
  2. Navegue para Build, Execution, Deployment > Compiler.
  3. No campo de texto ao lado de Command-line Options, insira suas opções de linha de comando.
  4. Clique em OK para salvar e sair.

O Gradle aplicará essas opções de linha de comando na próxima vez que você tentar compilar seu app.

Sobre o Instant Run

No Android Studio 2.3 e versões posteriores, o Instant Run reduz significativamente o tempo necessário para atualizar seu APK com alterações de código e recurso. Depois de implantar seu app em um dispositivo de destino executando o Android 5.0 (API de nível 21) ou posterior, clique em Apply Changes para enviar determinadas alterações de código e recursos ao app em execução sem criar um novo APK e, em alguns casos, sem sequer reiniciar a atividade atual. Os botões Run e Debug estão sempre disponíveis para você enviar suas alterações e forçar o reinício de um app. No entanto, você pode descobrir que usar o botão Apply Changes oferece um fluxo de trabalho mais rápido para a maioria das alterações incrementais no app.

Dica: você também pode pressionar Control + F10 (ou Control + Command + R no Mac) para aplicar as alterações com o Instant Run.

A ação Apply Changes está disponível somente quando você atende às seguintes condições:

  • Cria um APK do app usando uma variante de compilação de depuração. O Instant Run ainda não é compatível para implantação a partir de um pacote de apps.
  • Usa o plug-in do Android para Gradle versão 2.3.0 ou posterior.
  • Define minSdkVersion como 15 ou superior no arquivo build.gradle de nível de módulo do app.
  • Implanta o app em um dispositivo de destino que executa o Android 5.0 (API de nível 21) e posterior.

Para mais informações sobre como ativar o Instant Run, acesse a seção sobre como como configurar seu projeto.

O Instant Run envia as alterações realizando um hot swap, warm swap ou cold swap. O tipo de swap executado depende do tipo de alteração feita. Quando você clica em Apply Changes depois de fazer uma alteração de código ou recurso no app em execução, o Instant Run determina automaticamente a melhor maneira de enviar a alteração para o dispositivo de destino, conforme descrito na tabela a seguir.

Clicar em Run (ou Debug ) força um cold swap e uma reinicialização do app. Se você fizer uma alteração no manifesto do app ou em um recurso mencionado pelo manifesto, o Android Studio sempre enviará as alterações com uma reinstalação completa do APK.

Alteração de código Comportamento em Apply Changes
  • Alteração do código de implementação de um método existente

Executa um hot swap: esse é o tipo mais rápido e torna as alterações visíveis muito mais rapidamente. O app continua em execução, e um método stub com a nova implementação será usado na próxima vez em que ele for chamado.

Hot swaps não reinicializam objetos no app em execução. Antes de você ver algumas atualizações, talvez seja necessário reiniciar a atividade atual, selecionando Run > Restart Activity ou reiniciar o app, clicando em Run. (ou Debug ). Por padrão, o Android Studio automaticamente reinicia a atividade atual após realizar um hot swap. Se não quiser esse comportamento, você poderá desativar as reinicializações automáticas de atividades.

  • Alteração ou remoção de um recurso existente
Executa um warm swap: esse ainda é muito rápido, mas o Instant Run precisa reiniciar a atividade atual quando ela envia os recursos alterados ao app. O app continua em execução, mas a tela pode apresentar uma breve oscilação conforme a atividade é reiniciada, o que é normal.
Alterações no código estrutural, como:
  • Adição, remoção ou alteração de:
    • uma anotação;
    • um campo de instância;
    • um campo estático;
    • uma assinatura de método estático;
    • uma assinatura de método de instância.
  • Alteração de qual classe pai gera a classe atual
  • Alteração da lista de interfaces implementadas
  • Alteração do inicializador estático da classe
  • Reordenação de elementos de layout que usam IDs de recurso dinâmicos

Executa um cold swap: esse é um pouco mais lento porque, embora um novo APK não seja necessário, o Instant Run precisa reiniciar todo o app quando ele enviar alterações no código estrutural.

  • Alteração no manifesto do app
  • Alteração de recursos referenciados pelo manifesto do app
  • Alteração em um elemento de IU do sistema Android, como um widget ou uma notificação

Ao fazer alterações no manifesto do app ou nos recursos referenciados pelo manifesto, clicar em Apply Changes reimplanta uma versão completa do app com essas alterações. Isso ocorre porque determinadas informações sobre o app, como nome, recursos de ícone do app e filtros de intent, são determinadas pelo manifesto quando o APK é instalado no dispositivo.

Se o processo de compilação atualizar automaticamente qualquer parte do manifesto do app, como iteração automática de versionCode ou versionName, você não poderá se beneficiar de todo o desempenho do Instant Run. Ao usar o Instant Run, desative as atualizações automáticas para qualquer parte do manifesto do app nas variantes de compilação de depuração.

Ao atualizar um elemento da IU do sistema Android, como um widget ou uma notificação, você precisa clicar em Run (ou Debug ).

Observação: se for necessário reiniciar o app após uma falha, não o inicie a partir do dispositivo de destino. Reiniciar o app pelo dispositivo de destino não aplica as alterações de código desde o último cold swap ou compilação incremental. Para iniciar o app com todas as alterações recentes, clique em Run (ou Debug) no Android Studio.

Desativar a reinicialização automática de atividades

Ao executar um hot swap, seu app continua em execução, mas o Android Studio reinicia automaticamente a atividade atual. Para desativar essa configuração padrão:

  1. Abra a caixa de diálogo Settings ou Preferences.
    • No Windows ou no Linux, selecione File > Settings na barra de menus.
    • No Mac OSX, selecione Android Studio > Preferences na barra de menus.
  2. Navegue até Build, Execution, Deployment > Instant Run.
  3. Desmarque a caixa ao lado de Restart activity on code changes.

Se a reinicialização automática de atividades estiver desativada, você poderá reiniciar a atividade atual manualmente pela barra de menus selecionando Run > Restart Activity.

Configurar o projeto para o Instant Run

O Android Studio ativa o Instant Run por padrão para projetos compilados usando o plug-in do Android para Gradle 2.3.0 ou versão posterior.

Para atualizar um projeto existente com a versão mais recente do plug-in:

  1. Abra a caixa de diálogo Settings ou Preferences.
  2. Navegue para Build, Execution, Deployment > Instant Run e clique em Update Project, conforme mostrado na Figura 4.

    Se a opção de atualizar o projeto não for exibida, ele já está atualizado com a versão mais recente do plug-in do Android para Gradle. No entanto, verifique se a caixa ao lado de Enable Instant Run está marcada.

    Figura 4. Atualização do plug-in do Android para Gradle para um projeto existente.

Para começar a usar o Instant Run, você também precisa alterar a variante de compilação para uma versão de depuração do seu app e implantá-la em um dispositivo de destino que execute o Android 5.0 (API de nível 21) ou versão posterior. Para saber mais técnicas que aceleram a compilação, leia Otimizar a velocidade da sua compilação.

Excluir seu projeto do Windows Defender

Em sistemas Windows, o Windows Defender pode causar lentidão durante o uso do Instant Run. Se você estiver usando o Windows Defender, é recomendável excluir a pasta do seu projeto do Android Studio das verificações de malware do Windows Defender (link em inglês).

Melhorar os tempos de compilação ao usar o Crashlytics

Se sua versão do plug-in Fabric Gradle for anterior à 1.21.6, o Crashlytics poderá aumentar os tempos de compilação. Para melhorar o desempenho de compilação ao desenvolver o app, você pode atualizar o plug-in para a versão mais recente ou desativar o Crashlytics para sua variante de compilação de depuração.

Limitações do Instant Run

O Instant Run foi projetado para agilizar o processo de compilação e implantação na maioria das situações. No entanto, alguns aspectos do Instant Run podem afetar o comportamento e a compatibilidade com o app. Se você tiver algum outro problema durante o uso do Instant Run, ative a geração de registros extra e informe um bug.

Implantação em vários dispositivos

O Instant Run usa diferentes técnicas para executar hot, warm e cold swaps específicos ao nível de API do dispositivo de destino. Por esse motivo, ao implantar um app em vários dispositivos de uma vez, o Android Studio desativa o Instant Run temporariamente.

Multidexação do seu app

Se minSdkVersion for definido para 21 ou mais, o Instant Run configurará seu app automaticamente para multidexar. Como o Instant Run só funciona com a versão de depuração do app, pode ser preciso configurar o app para multidex ao implantar sua variante de compilação de versão.

Execução de testes instrumentados e criadores de perfil de desempenho

Testes instrumentados carregam o APK de depuração e um APK de teste no mesmo processo em um dispositivo de teste, permitindo que métodos de controle modifiquem o ciclo de vida normal do app e executem testes. Ao executar ou depurar testes instrumentados, o Android Studio não injeta outros métodos necessários para o Instant Run e desativa o recurso.

Ao criar um perfil de app, você precisa desativar o Instant Run. Há um pequeno impacto no desempenho ao usar o Instant Run e um impacto ligeiramente maior ao substituir métodos com um hot swap. Esse impacto no desempenho pode interferir nas informações fornecidas pelas ferramentas de geração de perfis de desempenho. Além disso, os métodos stub gerados com cada hot swap podem complicar rastreamentos de pilha.

Usar plug-ins de terceiros

O Android Studio desativa temporariamente a Java Code Coverage Library (JaCoCo) e o ProGuard ao usar o Instant Run. Como o Instant Run só funciona com compilações de depuração, isso não afeta a compilação de lançamento.

Alguns plug-ins de terceiros que realizam melhorias de bytecode podem causar problemas na instrumentação do Instant Run para seu app. Se você tiver esses problemas, mas quiser continuar usando o Instant Run, desative esses plug-ins para sua variante de compilação de depuração. Também é possível melhorar a compatibilidade com plug-ins de terceiros registrando um bug.

Enviar alterações para apps de vários processos

O Instant Run só instrumenta o processo principal do seu app para executar hot swaps e warm swaps. Ao enviar alterações de código para outros processos do app, como alterações em uma implementação de método ou um recurso existente, o Instant Run executa um cold swap.

Abrir seu app em um perfil de trabalho

Se você executar o app com o Instant Run e o abrir usando um perfil de trabalho (ou outro perfil secundário), ele falhará porque os arquivos DEX instrumentados usados pelo Instant Run só poderão ser acessados pelo espaço do usuário do perfil principal.

Se você quiser continuar usando o Instant Run, evite abrir o app com o perfil de trabalho e assegure que sua configuração de execução não use a sinalização --user user_id.

Se você precisar usar seu app com o perfil de trabalho, recomendamos criar uma nova configuração de execução que inclua a sinalização --user user_id, especificando o ID do usuário do perfil de trabalho. Você pode encontrar o ID do usuário executando adb shell pm list users na linha de comando. Quando você usa a sinalização --user, o Android Studio desativa o Instant Run apenas para essa implantação. O Instant Run funcionará novamente quando você alternar para uma configuração sem a sinalização --user.

Desativar o Instant Run

Para desativar o Instant Run:

  1. Abra a caixa de diálogo Settings ou Preferences.
  2. Navegue até Build, Execution, Deployment > Instant Run.
  3. Desmarque a caixa ao lado de Enable Instant Run.