Migrar para o Android Studio

A migração de projetos para o Android Studio exige a adaptação a uma nova estrutura de projeto, ao sistema de compilação e às funcionalidades do ambiente de desenvolvimento integrado. Para migrações de projetos Android do Eclipse, o Android Studio oferece uma ferramenta de importação que permite mover rapidamente o código existente para projetos do Android Studio e arquivos de compilação com base no Gradle. Para ver mais informações, consulte Migrar do Eclipse.

Se você está migrando do IntelliJ e o projeto já usa o Gradle, basta abrir o projeto existente no Android Studio. Se você está usando o IntelliJ, mas o projeto ainda não usa o Gradle, uma pequena preparação manual é necessária antes de importar o projeto para o Android Studio. Para ver mais informações, consulte Migrar do IntelliJ.

Conceitos básicos do Android Studio

Veja a seguir algumas das principais diferenças que você deve conhecer para preparar a migração para o Android Studio.

Organização de projetos e módulos

O Android Studio é baseado no ambiente de desenvolvimento integrado IntelliJ IDEA. Para conhecer os princípios básicos desse ambiente, como navegação, conclusão de código e atalhos de teclado, consulte Conheça o Android Studio.

O Android Studio não usa espaços de trabalho. Portanto, projetos separados são abertos em janelas distintas do Android Studio. O Android Studio organiza código em projetos, que contêm tudo o que define o app Android, desde o código-fonte até configurações da compilação e código de teste. Cada projeto contém um ou mais módulos, que permitem dividir o projeto em unidades distintas de funcionalidade. Os módulos podem ser compilados, testados e depurados independentemente.

Para ver mais informações sobre projetos e módulos do Android Studio, consulte a Visão geral de projetos.

Sistema de compilação baseado em Gradle

O sistema de compilação do Android Studio é baseado no Gradle e usa arquivos de configuração de compilação escritos na sintaxe do Groovy para facilitar a capacidade de ampliação e a personalização.

Projetos baseados no Gradle oferecem recursos consideráveis para o desenvolvimento em Android, entre eles:

  • Compatibilidade com bibliotecas binárias (AARs). Não é mais necessário copiar origens de bibliotecas nos próprios projetos. Basta declarar uma dependência, e a biblioteca é automaticamente transferida por download e combinada ao projeto. Isso inclui a combinação automática de recursos, entradas de manifesto, regras de exclusão do ProGuard e regras de lint personalizadas, entre outros, durante a compilação.
  • Compatibilidade com variações de compilação. Por exemplo, variações de compilação permitem compilar versões diferentes do app (como uma versão gratuita e uma versão Pro) para o mesmo projeto.
  • Facilidade de configuração e personalização de compilações. Por exemplo, é possível recuperar nomes e códigos de versão a partir de tags do Git como parte da compilação.
  • O Gradle pode ser usado a partir do ambiente de desenvolvimento integrado, mas também da linha de comando e de servidores de integração contínua, como o Jenkins, o que gera a mesma compilação em qualquer lugar, a qualquer momento.

Para ver mais informações sobre como usar e configurar o Gradle, consulte Configurar sua compilação.

Dependências

As dependências de biblioteca no Android Studio usam declarações de dependência do Gradle e dependências do Maven para bibliotecas de origem e binárias locais conhecidas com coordenadas do Maven. Para saber mais, leia Configurar variações de compilação.

Código de teste

No Eclipse ADT, testes de instrumentação são escritos em projetos separados e integrados por meio do elemento <instrumentation> ao arquivo de manifesto. O Android Studio disponibiliza um diretório androidTest/ no conjunto de origem principal do projeto para que você possa adicionar e manter facilmente o código de teste de instrumentação na mesma visualização de projeto. Além disso, o Android Studio oferece um diretório test/ no conjunto de origem principal do projeto para testes locais da JVM.

Migrar do Eclipse

O Android Studio oferece uma ferramenta de importação automática para projetos Android criados com o Eclipse.

Pré-requisitos de migração

Antes de migrar o app do Eclipse para o Android Studio, veja as etapas a seguir para garantir que o projeto esteja pronto para conversão e verifique se as configurações de ferramentas necessárias estão no Android Studio:

No Eclipse ADT:

  • Verifique se o diretório raiz do Eclipse ADT contém o arquivo AndroidManifest.xml. Além disso, o diretório raiz precisa conter os arquivos .project e .classpath do Eclipse ou os diretórios res/ e src/.
  • Compile o projeto para garantir que as atualizações mais recentes de espaço de trabalho e projeto sejam salvas e incluídas na importação.
  • Transforme em comentários todas as referências aos arquivos de biblioteca do espaço de trabalho do Eclipse ADT nos arquivos project.properties ou .classpath a serem importados. Você pode adicionar essas referências no arquivo build.gradle depois da importação. Para ver mais informações, consulte Configurar sua compilação.
  • Pode ser útil registrar o diretório do espaço de trabalho, as variáveis de caminho e todos os mapeamentos de caminho reais que podem ser usados para especificar caminhos relativos, variáveis e referências de recursos vinculados não resolvidos. O Android Studio permite especificar manualmente todos os caminhos não resolvidos durante o processo de importação.

No Android Studio:

  • Faça o download do Android Studio, caso ainda não tenha feito. Se você já tem o Android Studio, verifique se tem a versão estável mais recente clicando em Help > Check for Updates (no Mac, Android Studio > Check for Updates).
  • Como o Android Studio não migra nenhum plug-in de terceiros do Eclipse ADT, anote todos os plug-ins de terceiros que você usa no Eclipse. Você pode verificar se há recursos equivalentes no Android Studio ou pesquisar um plug-in compatível no repositório de plug-ins para Android Studio do IntelliJ. Use a opção de menu File > Settings > Plugins para gerenciar plug-ins no Android Studio.
  • Se você pretende executar o Android Studio atrás de um firewall, defina as configurações de proxy para o Android Studio e o SDK Manager. O Android Studio exige conexão de Internet para sincronização do assistente de configuração, acesso a bibliotecas de terceiros, acesso a repositórios remotos, inicialização e sincronização do Gradle e atualizações de versão do Android Studio. Para ver mais informações, consulte Configurações de proxy.

Importar projetos do Eclipse para o Android Studio

Decida como importará os projetos atuais do Eclipse ADT de acordo com a estrutura deles:

  • Se você tem vários projetos relacionados compartilhando o mesmo espaço de trabalho no Eclipse ADT, importe o primeiro como um projeto e adicione os projetos relacionados subsequentes como módulos desse projeto.
  • Se os projetos do Eclipse ADT compartilham dependências no mesmo espaço de trabalho, mas não têm qualquer outra relação, importe cada projeto do Eclipse ADT individualmente para o Android Studio como um projeto separado. O Android Studio mantém as dependências compartilhadas entre os projetos recém-criados como parte do processo de importação.
  • Se o projeto Eclipse ADT inclui bibliotecas nativas (C/C++), consulte Vincular o Gradle à sua biblioteca nativa para ver instruções de como incluir suas bibliotecas nativas como dependências de compilação do Gradle.

Importar como projeto:

  1. Inicie o Android Studio e feche todos os projetos abertos nele.
  2. No menu do Android Studio, clique em File > New > Import Project.
    • Como alternativa, na tela "Welcome", clique em Import project (Eclipse ADT, Gradle etc.).
  3. Selecione a pasta de projetos do Eclipse ADT com o arquivo AndroidManifest.xml e clique em OK.

  4. Selecione a pasta de destino e clique em Next.

  5. Selecione as opções de importação e clique em Finish.
  6. Durante o processo de importação, você verá uma solicitação para migrar todas as dependências de bibliotecas e projetos para o Android Studio e adicionar as declarações de dependência ao arquivo build.gradle. Consulte Criar uma biblioteca do Android para ver mais informações sobre esse processo.

    O processo de importação também substitui todas as bibliotecas de origem e binárias conhecidas e os arquivos JAR que têm coordenadas Maven conhecidas com dependências do Maven. Portanto, não é mais necessário manter essas dependências manualmente. As opções de importação também permitem inserir o diretório do espaço de trabalho e todos os mapeamentos de caminho reais para lidar com quaisquer caminhos, variáveis de caminho e referências de recursos vinculados não resolvidos.

  7. O Android Studio importa o app e exibe o resumo da importação do projeto. Leia o resumo para ver detalhes sobre a reestruturação do projeto e o processo de importação.

Após a importação do projeto do Eclipse ADT para o Android Studio, cada pasta de módulo de app no Android Studio conterá o conjunto de origem completo para esse módulo, incluindo os diretórios src/main/ e src/androidTest/, recursos, arquivo de compilação e manifesto do Android. Antes de iniciar o desenvolvimento do app, é preciso resolver todos os problemas mostrados no resumo de importação do projeto para ter certeza de que a reestruturação e o processo de importação foram concluídos corretamente.

Importar como módulo:

  1. Inicie o Android Studio e abra o projeto ao qual você quer adicionar o módulo.
  2. No menu do Android Studio, clique em File > New > Import Module.
  3. Selecione a pasta de projetos do Eclipse ADT com o arquivo AndroidManifest.xml e clique em OK.
  4. Modifique o nome do módulo, se quiser, e clique em Next.
  5. Durante o processo de importação, você verá uma solicitação para migrar todas as dependências de bibliotecas e projetos para o Android Studio e adicionar as declarações de dependência ao arquivo build.gradle. Para ver mais informações sobre a migração de dependências de biblioteca e projeto, consulte Criar uma biblioteca do Android. O processo de importação também substitui todas as bibliotecas de origem e binárias conhecidas e os arquivos JAR que têm coordenadas Maven conhecidas com dependências do Maven. Portanto, não é mais necessário manter essas dependências manualmente. As opções de importação também permitem inserir o diretório do espaço de trabalho e todos os mapeamentos de caminho reais para lidar com quaisquer caminhos, variáveis de caminho e referências de recursos vinculados não resolvidos.
  6. Clique em Finish.

Validar projetos importados

Depois de concluir o processo de importação, use as opções de menu "Build" e "Run" do Android Studio para compilar o projeto e verificar a saída. Se o projeto não estiver sendo compilado corretamente, verifique as configurações a seguir:

  • Verifique se as versões instaladas das ferramentas correspondem às configurações do projeto Eclipse. Para isso, clique no botão "Android SDK Manager" no Android Studio ou em Tools > Android > SDK Manager para abrir o SDK Manager. O Android Studio herda as configurações do SDK Manager e do JDK do projeto importado do Eclipse.
  • Para conferir outras configurações do Android Studio, clique em File > Project Structure e verifique o seguinte:

    • Em SDK Location, verifique se o Android Studio tem acesso aos locais e versões corretos de SDK, NDK e JDK.

    Observação: se você usou as configurações padrão, o Eclipse ADT instalou o Android SDK em User\user-name\android-sdks\ no Windows e em Users/user-name/Library/Android/sdk/ no Mac.

    • Em Project, verifique a versão do Gradle, a versão do plug-in do Android e os repositórios relacionados.
    • Em Modules, verifique as configurações de app e módulo, como configuração de assinatura e dependências de biblioteca.
  • Se o projeto depende de outro projeto, verifique se essa dependência está definida corretamente no arquivo build.gradle na pasta do módulo do app. Para ver mais informações sobre a definição de dependências, consulte Configurar variações de compilação.

Se, depois de verificar essas configurações, os problemas inesperados persistirem durante a compilação e execução do projeto no Android Studio, modifique o projeto do Eclipse ADT e reinicie o processo de importação.

Observação: a importação de um projeto do Eclipse ADT para o Android Studio cria um novo projeto do Android Studio e não afeta o projeto existente do Eclipse ADT.

Migrar do IntelliJ

Se o projeto do IntelliJ usar o sistema de compilação do Gradle, você poderá importar o projeto automaticamente para o Android Studio. Se o projeto do IntelliJ usar o Maven ou outro sistema de compilação, será necessário configurá-lo para usar o Gradle antes de fazer a migração para o Android Studio.

Importar um projeto do IntelliJ baseado no Gradle

Se você já usa o Gradle com o projeto do IntelliJ, pode abri-lo no Android Studio seguindo as etapas a seguir:

  1. Clique em File > New > Import Project.
  2. Selecione o diretório do projeto do IntelliJ e clique em OK. Seu projeto será aberto no Android Studio.

Importar um projeto do IntelliJ que não usa o Gradle

Se o projeto do IntelliJ ainda não usa o sistema de compilação Gradle, você tem duas opções para importar o projeto para o Android Studio:

Migrar criando um novo projeto vazio

Para migrar o projeto para o Android Studio criando um novo projeto vazio e copiando os arquivos de origem para os novos diretórios, faça o seguinte:

  1. Abra o Android Studio e clique em File > New > New Project.
  2. Insira um nome para o projeto do app, especifique o local onde ele deve ser criado e clique em Next.
  3. Selecione os formatos onde o app será executado e clique em Next.
  4. Clique em Add No Activity e em Finish.
  5. Na janela Project da ferramenta, clique na seta para abrir uma lista suspensa e selecione a visualização Project para ver e analisar a organização do novo projeto do Android Studio. Para ler mais sobre como alterar visualizações e como o Android Studio estrutura projetos, consulte Project Files.
  6. Navegue até o local selecionado para o novo projeto e mova o código, testes de unidade, testes de instrumentação e recursos dos diretórios do projeto antigo para os locais corretos na estrutura do novo projeto.
  7. No Android Studio, clique em File > Project Structure para abrir a caixa de diálogo Project Structure. Verifique se o módulo do app está selecionado no painel esquerdo.
  8. Faça as modificações necessárias na guia Properties do projeto (por exemplo, modifique minSdkVersion ou targetSdkVersion).
  9. Clique em Dependencies e adicione todas as bibliotecas de que o projeto depende como dependências do Gradle. Para adicionar uma nova dependência, clique em Add , selecione o tipo de dependência que gostaria de adicionar e siga as instruções.
  10. Clique em OK para salvar as modificações.
  11. Clique em Build > Make Project para testar a compilação do projeto e resolva todos os erros pendentes.

Migrar criando um arquivo de compilação personalizado do Gradle

Para migrar o projeto para o Android Studio criando um novo arquivo de compilação do Gradle que aponte para arquivos de origem existentes, faça o seguinte:

  1. Antes de começar, faça backup dos arquivos do projeto em um local separado, porque o processo de migração modificará o conteúdo do projeto atual.
  2. Em seguida, crie um arquivo no diretório do projeto com o nome build.gradle. O arquivo build.gradle conterá todas as informações necessárias para a compilação pelo Gradle.

    Por padrão, o Android Studio espera que o projeto seja organizado como mostrado na figura 1.

    Figura 1. Estrutura padrão do projeto para um módulo de app Android.

    Como seu projeto do IntelliJ não usa a mesma estrutura, o arquivo build.gradle precisa definir os diretórios de origem da compilação como as pastas existentes (por exemplo, res/ e src/), em vez da nova estrutura de diretórios padrão. O exemplo de arquivo build.gradle a seguir inclui a configuração básica de uma compilação do Gradle, bem como um bloco sourceSets{} dentro do bloco android{} para definir os diretórios de origem corretos e mover os testes e tipos de compilação para evitar conflitos de nomenclatura. Copie o bloco de código abaixo no arquivo build.gradle e faça todas as alterações necessárias para trabalhar com a configuração do projeto existente. Por exemplo, pode ser necessário incluir mais dependências, usar uma versão de destino de SDK diferente ou especificar outros locais para os diretórios de origem.
        // This buildscript{} block configures the code driving the build
        buildscript {
           /**
            * The nested repositories{} block declares that this build uses the
            * jcenter repository.
            */
            repositories {
                jcenter()
            }
    
           /**
            * This block declares a dependency on the 3.5.0 version
            * of the Gradle plugin for the buildscript.
            */
            dependencies {
                classpath 'com.android.tools.build:gradle:3.5.0'
            }
        }
    
        /**
         * This line applies the com.android.application plugin. Note that you should
         * only apply the com.android.application plugin. Applying the Java plugin as
         * well will result in a build error.
         */
        apply plugin: 'com.android.application'
    
        /**
         * This dependencies block includes any dependencies for the project itself. The
         * following line includes all the JAR files in the libs directory.
         */
        dependencies {
            compile fileTree(dir: 'libs', include: ['*.jar'])
            // Add other library dependencies here (see the next step)
        }
    
        /**
         * The android{} block configures all of the parameters for the Android build.
         * You must provide a value for at least the compilation target.
         */
        android {
            compileSdkVersion 28
    
            /**
            * This nested sourceSets block points the source code directories to the
            * existing folders in the project, instead of using the default new
            * organization.
            */
            sourceSets {
                main {
                    manifest.srcFile 'AndroidManifest.xml'
                    java.srcDirs = ['src']
                    resources.srcDirs = ['src']
                    aidl.srcDirs = ['src']
                    renderscript.srcDirs = ['src']
                    res.srcDirs = ['res']
                    assets.srcDirs = ['assets']
                }
    
                // Move the tests to tests/java, tests/res, etc...
                instrumentTest.setRoot('tests')
    
               /**
                * Move the build types to build-types/<type>
                * For instance, build-types/debug/java, build-types/debug/AndroidManifest.xml, ...
                * This moves them out of them default location under src/<type>/... which would
                * conflict with src/ being used by the main source set.
                * Adding new build types or product flavors should be accompanied
                * by a similar customization.
                */
                debug.setRoot('build-types/debug')
                release.setRoot('build-types/release')
             }
        }
        
    Para ver mais informações sobre a configuração e a personalização de um arquivo de compilação do Gradle, leia Configurar sua compilação.
  3. Em seguida, identifique quais projetos de biblioteca você está usando. Com o Gradle, não é mais necessário adicionar essas bibliotecas como projetos de código-fonte. Em vez disso, elas podem ser referenciadas no bloco dependencies{} do arquivo de compilação. O sistema de compilação processará essas bibliotecas, incluindo o download, a combinação dos recursos e a combinação das entradas de manifesto. O exemplo a seguir adiciona as instruções de declaração do Google Play Services e diversas bibliotecas de suporte ao bloco dependencies{} mostrado no exemplo de arquivo de compilação acima.
        ...
        dependencies {
            compile fileTree(dir: 'libs', include: ['*.jar'])
    
            // Google Play Services
            compile 'com.google.android.gms:play-services:9.8.0'
    
            // Support Libraries
            compile 'com.android.support:appcompat-v7:28.0.0'
            compile 'com.android.support:cardview-v7:28.0.0'
            compile 'com.android.support:design:28.0.0'
            compile 'com.android.support:gridlayout-v7:28.0.0'
            compile 'com.android.support:leanback-v17:28.0.0'
            compile 'com.android.support:mediarouter-v7:28.0.0'
            compile 'com.android.support:palette-v7:28.0.0'
            compile 'com.android.support:recyclerview-v7:28.0.0'
            compile 'com.android.support:support-annotations:28.0.0'
            compile 'com.android.support:support-v13:28.0.0'
            compile 'com.android.support:support-v4:28.0.0'
    
            // Note: these libraries require the "Google Repository" and "Android Repository"
            //       to be installed via the SDK manager.
        }
        
    Para receber ajuda na determinação das instruções de declaração corretas para suas bibliotecas, consulte Gradle, please (link em inglês) para ver as instruções certas com base no Maven Central.
  4. Salve o arquivo build.gradle e feche o projeto no IntelliJ. Vá até o diretório do projeto e exclua o diretório .idea e todos os arquivos .iml dentro do projeto.
  5. Inicie o Android Studio e clique em File > New > Import Project.
  6. Localize o diretório do projeto, clique no arquivo build.gradle criado acima para selecioná-lo e clique em OK para importar o projeto.
  7. Clique em Build > Make Project para testar o arquivo de compilação, compilando o projeto e resolvendo todos os erros encontrados.

A seguir

Depois de migrar o projeto para o Android Studio, leia Compilar e executar seu app para saber mais sobre a compilação com o Gradle e a execução do app no Android Studio.

Dependendo do projeto e do fluxo de trabalho, você também pode se interessar por controle de versões, gerenciamento de dependências, assinatura e empacotamento de apps ou configuração e atualização do Android Studio. Para começar a usar o Android Studio, leia Conheça o Android Studio.

Configurar o controle de versões

O Android Studio é compatível com diversos sistemas de controle de versões, incluindo Git, GitHub, CVS, Mercurial, Subversion e Google Cloud Source Repositories.

Depois de importar o app para o Android Studio, use as opções do menu "VCS" do Android Studio para ativar a compatibilidade do VCS com o sistema de controle de versões em questão, criar um repositório, importar os novos arquivos para o controle de versões e realizar outras operações de controle de versões.

  1. No menu "VCS" do Android Studio, clique em Enable Version Control Integration.
  2. Selecione um sistema de controle de versões para associar à raiz do projeto no menu suspenso e clique em OK. Então, serão exibidas diversas opções de controle de versões no menu "VCS", de acordo com o sistema selecionado.

Observação: também é possível usar a opção de menu File > Settings > Version Control para definir e modificar as configurações do controle de versões.

Para ver mais informações sobre como trabalhar com o controle de versões, consulte Referência do controle de versões do IntelliJ.

Repositórios de Suporte do Android Support e Repositório do Google Play Services

Embora o Eclipse ADT use a Biblioteca de Suporte do Android e a Biblioteca do Google Play Services, o Android Studio substitui essas bibliotecas durante o processo de importação pelo Repositório de Suporte do Android e o Repositório do Google para manter funcionalidades compatíveis e aceitar novos recursos do Android. No Android Studio, essas dependências são adicionadas como dependências do Maven por meio das coordenadas conhecidas do Maven. Portanto, essas dependências não precisam ser atualizadas manualmente.

No Eclipse, para usar uma Biblioteca de Suporte, é necessário modificar as dependências de classpath do projeto no ambiente de desenvolvimento para cada Biblioteca de Suporte a ser usada. No Android Studio, não é mais necessário copiar origens de biblioteca nos projetos. Basta declarar uma dependência para que a biblioteca seja transferida por download e combinada automaticamente com o projeto. Isso inclui a combinação automática em recursos, entradas de manifesto, regras de exclusão do ProGuard e regras de lint personalizadas no momento da compilação. Para ver mais informações sobre dependências, consulte Configurar variações de compilação.

Assinatura de apps

Se um certificado de depuração foi usado pelo app no Eclipse ADT, o Android Studio continuará referenciando esse certificado. Caso contrário, a configuração de depuração usará o keystore de depuração gerado pelo Android Studio, com uma senha conhecida e uma chave padrão, localizado em $HOME/.android/debug.keystore. O tipo de compilação de depuração será definido para usar automaticamente essa configuração de depuração quando o projeto for executado ou depurado no Android Studio.

Na compilação do app para lançamento, o Android Studio aplica o certificado de lançamento usado no Eclipse ADT. Se nenhum certificado desse tipo for localizado durante o processo de importação, adicione a configuração de assinatura de lançamento ao arquivo build.gradle ou use a opção de menu Build > Generate Signed APK para abrir o assistente para gerar um APK assinado. Para ver mais informações sobre como assinar seu app, consulte Assinar seu app.

Ajustar o tamanho máximo de heap do Android Studio

Por padrão, o Android Studio tem um tamanho de heap máximo de 1280 MB. Se você estiver trabalhando em um projeto grande ou se seu sistema tiver muita RAM, será possível melhorar o desempenho aumentando o tamanho máximo de heap.

Atualizações de software

O Android Studio é atualizado separadamente do plug-in para Gradle, das ferramentas de compilação e das ferramentas do SDK. Você pode especificar quais versões quer usar com o Android Studio.

Por padrão, o Android Studio oferece atualizações automáticas sempre que uma nova versão estável é lançada. No entanto, é possível optar por atualizações mais frequentes e também receber versões de pré-lançamento ou Beta.

Para ver mais informações sobre como atualizar o Android Studio e usar versões de pré-lançamento e Beta, consulte Fique atualizado.