Migrar para o Android Studio

A migração de projetos para o Android Studio exige adaptação a uma nova estrutura de projeto, sistema de build e funcionalidades do ambiente de desenvolvimento integrado.

Se você está migrando do IntelliJ, e o projeto já usa o Gradle, abra o projeto no Android Studio. Se você está usando o IntelliJ, mas o projeto ainda não usa o Gradle, é necessário preparar seu projeto manualmente antes da importação para o Android Studio. Para mais informações, consulte a seção Migrar do IntelliJ.

Conceitos básicos do Android Studio

Descubra a seguir algumas das principais diferenças que você precisa 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 (link em inglês). Para conhecer os princípios básicos desse ambiente, como navegação, preenchimento de código e atalhos de teclado, consulte Conheça o 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 de build e código de teste. Os projetos são abertos em janelas separadas do Android Studio. 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 de forma independente.

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

Sistema de build baseado em Gradle

O sistema de build do Android Studio é baseado no Gradle (link em inglês) e usa arquivos de configuração de build criados na sintaxe do Groovy ou do Kotlin para facilitar a capacidade de ampliação e personalização.

Projetos baseados no Gradle oferecem recursos consideráveis para o desenvolvedor 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, no momento do build.
  • O suporte para variantes de build permite criar versões diferentes do app para o mesmo projeto, por exemplo, uma versão sem custos e uma paga.
  • Facilidade de configuração e personalização do build. Por exemplo, é possível extrair nomes e códigos de versão usando tags do Git como parte do build.
  • O Gradle pode ser usado no ambiente de desenvolvimento integrado, na linha de comando e em servidores de integração contínua, como o Jenkins. Ele sempre gera o mesmo build em qualquer lugar, a qualquer momento.

Para aprender como usar e configurar o Gradle, consulte Configurar seu build.

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 famosas que têm coordenadas do Maven. Para mais informações, consulte Declarar dependências.

Migrar do IntelliJ

Se o projeto do IntelliJ usa o sistema de build do Gradle, você pode importar o projeto diretamente para o Android Studio. Se o projeto do IntelliJ usa o Maven ou outro sistema de build, ele precisa ser configurado para usar o Gradle antes da 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, siga estas instruções no Android Studio:

  1. Clique em File > New > Import Project.
  2. Selecione o diretório do projeto IntelliJ e clique em OK. Seu projeto vai abrir 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 build do Gradle, você tem duas opções para importar o projeto para o Android Studio, conforme descrito nas seções abaixo.

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 em que ele deve ser criado e clique em Next.
  3. Selecione os formatos em que o app vai ser executado e clique em Next.
  4. Clique em Add No Activity e, em seguida, em Finish.
  5. Na janela Project da ferramenta, clique na seta para abrir o menu e selecione a visualização Project para conferir e explorar a organização do novo projeto do Android Studio. Para saber mais sobre como mudar visualizações e como o Android Studio estrutura projetos, consulte Arquivos de projetos.
  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 o minSdk ou o targetSdk.
  9. Clique em Dependencies e adicione todas as bibliotecas de que o projeto precisa 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 o build do projeto e, se necessário, resolva todos os erros pendentes.

Migrar criando um arquivo de build personalizado do Gradle

Para migrar o projeto para o Android Studio criando um novo arquivo de build do Gradle que aponte para arquivos de origem já 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 modifica o conteúdo do projeto atual.
  2. Crie um arquivo no diretório do projeto com o nome build.gradle, se estiver usando o Groovy, ou build.gradle.kts, se estiver usando o script Kotlin. Esse arquivo contém todas as informações necessárias para que o Gradle execute o build.

    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 app para Android.

    Em settings.gradle, no Groovy, ou settings.gradle.kts, no script Kotlin, defina os repositórios usados para encontrar plug-ins e dependências nos blocos pluginManagement e dependencyResolutionManagement, respectivamente:

    Groovy

      pluginManagement {
      repositories {
          google()
          mavenCentral()
          gradlePluginPortal()
      }
  }
  dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
          google()
          mavenCentral()
      }
  }
  rootProject.name = "Test App"
  include ':app'

    Kotlin

      pluginManagement {
      repositories {
          google()
          mavenCentral()
          gradlePluginPortal()
      }
  }
  dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
          google()
          mavenCentral()
      }
  }
  rootProject.name = "Test App"
  include(":app")

    Aviso: o repositório JCenter passou a ser somente leitura em 31 de março de 2021. Para mais informações, consulte a atualização do serviço JCenter.

    O Plug-in do Android para Gradle aplica alguns conjuntos de origem padrão ao projeto. Esses conjuntos definem os diretórios usados para armazenar vários tipos de arquivos de origem. O Gradle usa esses conjuntos de origem para determinar os locais de tipos específicos de arquivo. Caso o projeto já existente não siga os padrões, mova os arquivos para o local em que eles precisam estar ou mude os conjuntos de origem padrão para que o Gradle saiba onde os encontrar.

    Para mais informações sobre a configuração e a personalização de um arquivo de build do Gradle, leia Configurar seu build.

  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 build. O sistema de build processa essas bibliotecas, incluindo o download e as mesclagens dos recursos e das entradas de manifesto. O exemplo a seguir adiciona as instruções de declaração de várias bibliotecas AndroidX ao bloco dependencies{} de um arquivo de build.

    Groovy

    ...
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    // AndroidX libraries
    implementation 'androidx.core:core-ktx:1.13.1'
    implementation 'androidx.appcompat:appcompat:1.7.0'
    implementation 'androidx.cardview:cardview:1.0.0'
    implementation 'com.google.android.material:material:1.7.0'
    implementation 'androidx.gridlayout:gridlayout:1.0.0'
    implementation 'androidx.leanback:leanback:1.1.0-rc02'
    implementation 'androidx.mediarouter:mediarouter:1.7.0'
    implementation 'androidx.palette:palette-ktx:1.0.0'
    implementation 'androidx.recyclerview:recyclerview:1.3.2'
    implementation 'androidx.annotation:annotation:1.8.2'

    // Note: these libraries require that the Google repository has been declared
    // in the pluginManagement section of the top-level build.gradle file.
}

    Kotlin

    ...
dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))

    // AndroidX libraries
    implementation("androidx.core:core-ktx:1.13.1")
    implementation("androidx.appcompat:appcompat:1.7.0")
    implementation("androidx.cardview:cardview:1.0.0")
    implementation("com.google.android.material:material:1.7.0")
    implementation("androidx.gridlayout:gridlayout:1.0.0")
    implementation("androidx.leanback:leanback:1.1.0-rc02")
    implementation("androidx.mediarouter:mediarouter:1.7.0")
    implementation("androidx.palette:palette-ktx:1.0.0")
    implementation("androidx.recyclerview:recyclerview:1.3.2")
    implementation("androidx.annotation:annotation:1.8.2")

    // Note: these libraries require that the Google repository has been declared
    // in the pluginManagement section of the top-level build.gradle.kts file.
}
    Para receber ajuda ao determinar as instruções de declaração certas para suas bibliotecas, pesquise no repositório Maven do Google ou no repositório Maven Central (links em inglês).
  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 dele.
  5. Inicie o Android Studio e, em seguida, clique em File > New > Import Project.
  6. Localize o diretório do projeto, selecione o arquivo build.gradle ou build.gradle.kts criado e clique em OK para importar o projeto.
  7. Clique em Build > Make Project para testar o arquivo de build, criando o projeto e resolvendo todos os erros encontrados.

Próximas etapas

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

Dependendo do projeto e do fluxo de trabalho, também pode ser importante saber mais sobre controle de versões, gerenciamento de dependências e configuração do Android Studio. Para começar a usar o Android Studio, consulte Conheça o Android Studio.

Configurar o controle de versões

O Android Studio oferece suporte a vários sistemas de controle de versões, incluindo Git, Mercurial e Subversion. Além disso, outros sistemas podem ser adicionados com plug-ins.

Se o app já tem um controle de origem definido, talvez ele precise ser ativado no Android Studio. No menu "VCS", clique em Enable Version Control Integration e selecione o sistema de controle de versões adequado.

Se não há um controle de origem definido, você pode configurar um depois de importar o app para o Android Studio. Use as opções do menu "VCS" do Android Studio para ativar o suporte do VCS ao 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, em seguida, clique em OK. Várias opções de controle de versões vão ser exibidas no menu "VCS", dependendo do 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 mais informações sobre como trabalhar com o controle de versões, consulte a referência de controle de versões do IntelliJ (link em inglês).

Assinatura de apps

Se um certificado de depuração já tiver sido usado anteriormente, ele pode ser detectado durante o processo de importação. Nesse caso, o Android Studio continua a referenciar esse certificado. Caso contrário, a configuração de depuração usa o keystore de depuração gerado pelo Android Studio, com uma senha conhecida e uma chave padrão com senha conhecida, localizado em $HOME/.android/debug.keystore. O tipo de build de depuração é definido para usar automaticamente essa configuração de depuração quando o projeto é executado ou depurado no Android Studio.

Da mesma forma, o processo de importação pode detectar um certificado de lançamento já existente. Se nenhum certificado de lançamento tiver sido definido anteriormente, adicione a configuração de assinatura de lançamento ao arquivo build.gradle ou build.gradle.kts ou use a opção de menu Build > Generate Signed APK para abrir o assistente Generate APK. Para saber mais sobre como assinar seu app, consulte Assinar o 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ê está trabalhando em um projeto grande ou se o sistema tem muita memória RAM, é possível melhorar o desempenho, aumentando o tamanho máximo do heap.

Atualizações de software

O Android Studio é atualizado separadamente do plug-in para Gradle, das ferramentas de build 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 receber versões de pré-lançamento ou Beta.

Para saber mais sobre como atualizar o Android Studio e usar versões de pré-lançamento e Beta, leia as atualizações.