Migrar projeto android existente para gradle

Android com formiga

• Antes de apresentar o Android Studio, aplicativos Android são construídos com formiga (no Eclipse e no Idea)

• Tenho um aplicativo Android existente que é construído com o Ant, no restante desta dica vou demonstrar como migrar o aplicativo para o Gradle

• Usei o IntelliJ Idea para projetos baseados em formigas e irei usar o Android Studio com o projeto Gradle para Android

Projeto Ideia Existente

• A seguir está o meu projeto de saída (que constrói com formiga)

• O nome do projeto é SenZors. Ele contém src, res, lib, afirma etc.

Estrutura de projeto baseada em Gradle

• O projeto baseado em Gradle se parece com abaixo

└── project/
    └── module/
        └── build.gradle/
    └── build.gradle
    └── settings.gradle

• Projeto principal contém e arquivobuild.gradlesettings.gradle

• Cada módulo contém um arquivo separadobuild.gradle

Projeto vs Módulo

• Um projeto é um aplicativo Android completo. Os projetos podem consistir em um ou mais módulos.

• Módulo é um componente do projeto que pode construir, testar ou depurar independentemente

• Existem três tipos de módulos

1. Módulos de biblioteca Java
2. Módulos de biblioteca Android
3. Módulos de aplicativo Android

• Na estrutura do projeto acima moduleestá um módulo de aplicação

• Muitos aplicativos Android consistem em apenas um módulo de aplicativo. O sistema de compilação gera um pacote APK para módulos de aplicativo

• Mais informações – http://developer.android.com/sdk/installing/studio-build.html

arquivo settings.gradle

• Este arquivo informa ao gradle sobre quais módulos construir, por exemplo, do SenZors

include ':senz'

• Isso especifica a inclusão do senzmódulo ao construir nosso projeto SenZors

Arquivo build.gradle de nível superior

• É o arquivo de compilação do gradle de nível superior, que pode ser usado para definir opções de configuração comuns a todos os submódulos

• Darei mais detalhes sobre o conteúdo deste arquivo mais tardebuild.gradle

Arquivo build.gradle do módulo

• Cada módulo contém um arquivo separado , para que o módulo possa construir de forma independentebuild.gradle

• Ele pode definir configurações específicas do Android, configurações de dependência etc.

• Discutirei mais detalhes sobre o conteúdo deste arquivo mais tarde

Estrutura do módulo de aplicativo Gradle

• Meu principal nome de módulo de aplicativo é senz

└── senz/
    └── build/
    └── libs/
    └── src/
        └── main/
            └── java/
            └── res/
            └── asserts/
    └── build.gradle

• Ao migrar o projeto formiga existente para o gradle, precisamos mover o conteúdo do projeto formiga de acordo com a estrutura do projeto gradle

Migrando SenZors para gradle

• O projeto principal é SenZors, sou usado senzcomo o módulo principal do aplicativo

Definir a estrutura do projeto

• A seguir estão as etapas para criar a estrutura do projeto

1. Create new application module directory `senz` in `SenZors`
mkdir -p SenZors/senz/src/main/java

2. Move source codes to senz
mv SenZors/src/com SenZors/senz/src/main/java

3. Move res and asserts
mv SenZors/res SenZors/senz/src/main
mv SenZors/asserts SenZors/senz/src/main  

4. Move libs
mv SenZors/libs SenZors/senz/

5. Move AndroidManifest 
mv SenZors/AndroidManifest.xml SenZors/senz/src/main

6. Create gradle build  files
touch SenZors/build.gradle
touch SenZors/settings.gradle
touch SenZors/senz/build.gradle

Defina settings.gradle

• Defina quais módulos construir no arquivo settings.gradle (temos apenas um módulo de aplicativo senz)

include ':senz'

Build.gradle de nível superior

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.9.+'
    }
}

allprojects {
    repositories {
        mavenCentral()
    }
}

# Gradle wrapper task
task wrapper(type: Wrapper) {
    gradleVersion = '1.12'
}

• Existem duas partes principais aqui

configurações de buildscript

• Aqui configura o código que conduz a construçãobuildscript { ... }

• Ele declara que usa o repositório Maven Central e que existe uma dependência do classpath em um artefato Maven

• Este artefato é a biblioteca que contém o plugin Android para Gradle na versão 0.9.+

Tarefa de wrapper do Gradle

• O Gradle Wrapper é a maneira preferida de iniciar uma compilação do Gradle

• O wrapper Gradle consiste em um script em lote para suporte ao Windows e um script de shell para suporte em OS-X e Linux

• Esses scripts permitem que você execute uma compilação do Gradle sem exigir que o Gradle seja instalado em seu sistema (isso é muito útil na integração contínua com jenkins)

• No gradle acima, definimos gradle wrapper com gradle versão 1.12 ( gradleVersioné a versão que você gostaria que o projeto usasse)

• Agora execute o seguinte comando na linha de comando

gradle wrapper

• Este comando irá gerar mais alguns arquivos na raiz do seu projeto

└── SenZors
    └── gradlew
    └── gradlew.bat
    └── gradle
        └── wrapper
            └── gradle-wrapper.jar
            └── gradle-wrapper.properties

     ...

    └── build.gradle
    └── settings.gradle

• Na primeira vez que você executa o wrapper para uma versão específica do Gradle, ele baixa e armazena em cache os binários do Gradle para essa versão

• Esses arquivos Gradle Wrapper são projetados para serem confirmados no controle de origem.

• Então, qualquer pessoa pode construir o projeto sem ter que primeiro instalar e configurar uma versão específica do Gradle

• Agora você pode usar para construir o projeto./gradlew build

• Mais informações sobre o wrapper Gradle – http://www.gradle.org/docs/current/userguide/gradle_wrapper.html

arquivo build.gradle do módulo senz

apply plugin: 'android'

android {
    compileSdkVersion 19
    buildToolsVersion "19.1.0"

    defaultConfig {
        minSdkVersion 14
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }

    buildTypes {
        release {
            runProguard false
            debuggable false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
        }

        debug {
            debuggable true
        }
    }
}

dependencies {
    compile 'com.android.support:appcompat-v7:19.1.0'
    compile 'com.android.support:support-v4:19.1.0'
    compile 'com.google.android.gms:play-services:5.+'
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

• Poucas coisas interessantes aqui

aplicar plugin: ‘android’

• Aplica-se a esta construçãoAndroid plugin for Gradle

Opção de construção específica para Android

• android {…} configura todas as opções de compilação específicas do Android

• Ele especifica as versões do SDK, liberar / depurar configurações de compilação etc.

Dependências

• O elemento dependencies está fora e depois do elemento android

• Este elemento declara as dependências para este módulo

Sincronize o projeto com o Android Studio

• Abra o Android Studio e importe o projeto SenZors. Ele irá sincronizar o projeto gradle android

• Certifique-se de marcar a opção nas preferências do Android Studiouse default gradle wrapper

• A estrutura de diretório do projeto finalizada seria semelhante a abaixo

Construir a partir da linha de comando

# build project from command line
./gradlew build

# list all available gradle tasks 
./gradlew tasks

Referências

1. http://ryanharter.com/blog/2013/07/17/migrating-android-projects-to-gradle/
2. http://developer.android.com/sdk/installing/studio-build.html
3. http://spring.io/guides/gs/gradle-android/
4. http://gmariotti.blogspot.it/2013/10/common-tips-about-gradle.html
5. http://tools.android.com/tech-docs/new-build-system/user-guide