Skip to content

Most visited

Recently visited

navigation

Migrar para o Android Studio

Project: /studio/_project.yaml Book: /studio/guide/_book.yaml Subcategory: guide

A migração de projetos para o Android Studio exige adaptação para uma nova estrutura de projeto, sistema de compilação e funcionalidades de IDE. 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 obter mais informações, consulte Migrar do Eclipse.

Se você estiver migrando do IntelliJ e o projeto já usar o Gradle, bastará simplesmente abrir o projeto existente no Android Studio. Se você estiver usando o IntelliJ, mas o projeto não usar o Gradle, será necessária uma pequena preparação manual antes de importar o projeto para o Android Studio. Para obter 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 IDE IntelliJ IDEA. Para conhecer os conceitos básicos do IDE, 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 aplicativo Android, de código de origem do aplicativo a 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 criados, testados e depurados independentemente.

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

Sistema de compilação baseado no 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, incluindo:

Para obter 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 bem conhecidas com coordenadas do Maven. Para obter mais informações, consulte 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 adicionar e manter facilmente o código de teste de instrumentação na mesma visualização de projeto. Além disso, o Android Studio disponibiliza 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 aplicativo para o Android Studio, revise 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:

No Android Studio:

Importar projetos do Eclipse para o Android Studio

Você deve decidir como importará os projetos atuais do Eclipse ADT de acordo com a estrutura:

Importar como projeto:

  1. Inicie o Android Studio e feche todos os projetos abertos do Android Studio.
  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 do projeto 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. O processo de importação solicita que você migre todas as dependências de biblioteca e projeto para o Android Studio e adicione as declarações de dependência ao arquivo build.gradle. Consulte Criar uma biblioteca do Android para obter mais informações sobre esse processo.

    O processo de importação também substitui todas as bibliotecas de origem e binárias bem conhecidas e os arquivos JAR que têm coordenadas Maven conhecidas por 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 todos caminhos, variáveis de caminho e referências de recursos vinculados não resolvidos.

  7. O Android Studio importa o aplicativo e exibe o resumo da importação do projeto. Examine o resumo para obter 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 aplicativo 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 de aplicativos, é preciso resolver todos os problemas mostrados no resumo de importação do projeto para garantir que a reestruturação do projeto e o processo de importação concluíram corretamente.

Importar como módulo:

  1. Inicie o Android Studio e abra o projeto ao qual quer adicionar o módulo.
  2. No menu do Android Studio, clique em File > New > Import Module.
  3. Selecione a pasta do projeto 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. O processo de importação solicita que você migre todas as dependências de biblioteca e projeto para o Android Studio e adicione as declarações de dependência ao arquivo build.gradle. Para obter 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 bem conhecidas e os arquivos JAR que têm coordenadas Maven conhecidas por 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 todos caminhos, variáveis de caminho e referências de recursos vinculados não resolvidos.
  6. Clique em Finish.

Validar projetos importados

Após 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 compilar corretamente, verifique as configurações a seguir:

Se, após verificar essas configurações, os problemas inesperados persistirem durante a compilação e execução do projeto no Android Studio, considere modificar o projeto do Eclipse ADT e reiniciar 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 IntelliJ usar o sistema de compilação do Gradle, você poderá importar automaticamente o projeto para o Android Studio. Se o projeto IntelliJ usar o Maven ou outro sistema de compilação, será necessário configurá-lo para usar o Gradle antes de migrá-lo para o Android Studio.

Importar um projeto IntelliJ baseado no Gradle

Se você já usa o Gradle com o projeto IntelliJ, poderá abri-lo no Android Studio usando as seguintes etapas:

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

Importar um projeto IntelliJ que não usa o Gradle

Se o projeto IntelliJ não usar o sistema de compilação Gradle, você terá 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 aplicativo, especifique o local onde ele deve ser criado e clique em Next.
  3. Selecione os fatores de forma onde o aplicativo 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 a lista suspensa de visualizações e selecione a visualização Project para ver e explorar a organização do novo projeto do Android Studio. Para ler mais sobre a troca de 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, os testes de unidade, os testes de instrumentação e os 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 aplicativo 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 das quais 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, não deixe de fazer um backup dos arquivos do projeto em um local separado, pois 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 de projeto padrão de um módulo de aplicativo Android.

    Como o projeto 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 para o 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 visada de SDK diferente ou especificar locais diferentes 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.0.1 version
        * of the Gradle plugin for the buildscript.
        */
        dependencies {
            classpath 'com.android.tools.build:gradle:3.0.1'
        }
    }
    
    /**
     * 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 values for at least the build tools version and the
     * compilation target.
     */
    android {
        compileSdkVersion 26
        buildToolsVersion "26.0.2"
    
        /**
        * 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 obter 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 as bibliotecas usadas pelos projetos. 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 declarações para o 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:27.0.2'
        compile 'com.android.support:cardview-v7:27.0.2'
        compile 'com.android.support:design:27.0.2'
        compile 'com.android.support:gridlayout-v7:27.0.2'
        compile 'com.android.support:leanback-v17:27.0.2'
        compile 'com.android.support:mediarouter-v7:27.0.2'
        compile 'com.android.support:palette-v7:27.0.2'
        compile 'com.android.support:recyclerview-v7:27.0.2'
        compile 'com.android.support:support-annotations:27.0.2'
        compile 'com.android.support:support-v13:27.0.2'
        compile 'com.android.support:support-v4:27.0.2'
    
        // Note: these libraries require the "Google Repository" and "Android Repository"
        //       to be installed via the SDK manager.
    }
    
    Para obter ajuda na determinação das declarações corretas das bibliotecas, consulte Gradle, please para ver as declarações corretas, com base no Maven Central.
  4. Salve o arquivo build.gradle e feche o projeto no IntelliJ. Navegue 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.

Próximas etapas

Após migrar o projeto para o Android Studio, saiba mais sobre a compilação com o Gradle e a execução do aplicativo no Android Studio lendo Compilar e executar seu aplicativo.

Dependendo do projeto e do fluxo de trabalho, você também pode saber mais sobre controle de versões, gerenciamento de dependências, assinatura e empacotamento de aplicativos 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.

Após importar o aplicativo para o Android Studio, use as opções do menu VCS do Android Studio para ativar a compatibilidade de VCS com o sistema de controle de versão desejado, criar um repositório, importar os novos arquivos para o controle de versão e executar outras operações:

  1. No menu VCS do Android Studio, clique em Enable Version Control Integration.
  2. Selecione um sistema de controle de versões para associação à raiz do projeto no menu suspenso e clique em OK. Agora, o menu VCS exibe diversas opções de controle de versões, 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ão

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

Android Support Repository e Google Play Services Repository

Embora o Eclipse ADT use a Android Support Library e a Google Play Services Library, o Android Studio substitui essas bibliotecas durante o processo de importação pelo Android Support Repository e Google Repository para manter funcionalidades compatíveis e comportar os novos recursos do Android. O Android Studio adiciona essas dependências como dependências do Maven usando as 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 para os projetos. Basta declarar uma dependência para que a biblioteca seja baixada e mesclada automaticamente ao projeto. Isso inclui a mesclagem automática em recursos, entradas de manifesto, regras de exclusão do ProGuard e regras personalizadas de verificação de código suspeito no momento da compilação. Para obter mais informações sobre dependências, consulte Configurar variações de compilação.

Assinatura de aplicativos

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

Na compilação do aplicativo para lançamento, o Android Studio aplica o certificado de lançamento usado no Eclipse ADT. Se nenhum certificado de lançamento 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 Generate Signed APK Wizard. Para obter mais informações sobre como assinar o aplicativo, consulte Assinatura de aplicativos.

Ajustar o tamanho máximo de pilha do Android Studio

Por padrão, o tamanho máximo de pilha do Android Studio é 1.280 MB. Se você estiver trabalhando em um projeto grande ou se o sistema tiver bastante RAM disponível, será possível melhorar o desempenho aumentando o tamanho máximo da pilha nas opções de VM do Android Studio.

Para obter mais informações sobre a definição de configurações do Android Studio, consulte Configurar o Android Studio e Configuração do Android Studio.

Otimizar o projeto para Instant Run

Introduzido no Android Studio 2.0, o Instant Run é um comportamento dos comandos Run e Debug que reduz consideravelmente o tempo entre atualizações de um aplicativo. Mesmo que a primeira compilação demore mais para ser concluída, o Instant Run envia as atualizações subsequentes ao aplicativo sem compilar um novo APK. Assim, as alterações ficam visíveis com muito mais rapidez. Você pode aprimorar o processo de compilação do Instant Run alterando algumas configurações do Android Studio.

Para obter mais instruções sobre a configuração do projeto para aumentar o desempenho do Instant Run, consulte Configurar e otimizar seu projeto para o Instant Run.

Atualizações de software

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

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

Para obter mais informações sobre a atualização do Android Studio e o uso de versões de visualização e beta, consulte Fique atualizado.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience. (Dec 2017 Android Platform & Tools Survey)