Criando projetos Android com Maven

Esse artigo irá mostrar como criar uma aplicação Android simples usando Maven. Essa aplicação poderá servir de base para a criação de qualquer outra aplicação.

O que será criado

Criaremos uma aplicação Android que mostra a hora do dia, e compilaremos ela com o Maven.

O que será necessário

Em torno de 15 minutos
Seu editor de texto favorito ou uma IDE
JDK 6 ou mais recente
Android SDK
Um dispositivo Android ou um emulador

Como completar esse tutorial

Como a maioria dos guias, você pode começar do zero e completar cada etapa, ou pular etapas básicas que você já esteja familiarizado. De qualquer forma, você terminará com um código funcional.

Para começar do zero, começe pela seção Configurando o projeto.

Para pular etapas báscias, faça o seguinte:

Baixe e descompacte o repositório de código para esse guia, ou clone usando o Git: git clone https://github.com/spring-guides/gs-maven-android.git
entre no diretório gs-maven-android/initial
Pule para a seção Instalação do Maven.

Quando tiver terminado, você pode conferir o resultado com o código em gs-maven-android/complete.

Configurando o projeto

Em primeiro lugar, você precisa configurar um project Android para o Maven compilar. Para manter o foco no Maven, crie um projeto bem simples nesse momento. Se esse for sua primeira vez trabalhando com projetos Android, acesso o artigo Installing the Android Development Environment para obter ajuda na configuração de seu ambiente de desenvolvimento.

Criando a estrutura de diretórios

Em um diretório de sua escolha, crie a seguinte estrutura de sub-diretórios; por exemplo, com o seguinte comando em um Mac ou Linux:

mkdir -p src/main/java/org/hello

└── src
    └── main
        └── java
            └── org
                └── hello

Criar o arquivo de manifesto do Android

O arquivo de Manifesto do Android contém todas as informações necessárias para rodar a aplicação Android, e não pode ser compilada sem um.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.hello"
    android:versionCode="1"
    android:versionName="1.0.0" >
    <application android:label="@string/app_name" >
        <activity
            android:name=".HelloActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Adicione uma string. Strings podem ser referenciadas pela aplicação ou por arquivos de recurso.

res/values/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Android Maven</string>
</resources>

Agora defina a estrutura visual da interface ao usuário de sua aplicação.

res/layout/hello_layout.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView
    android:id="@+id/text_view"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    />
</LinearLayout>

Dentro do diretório src/main/java/org/hello, você pode criar qualquer classe Java que quiser. Para manter-se consistente com o restante do artigo, crie a seguinte classe:

src/main/java/org/hello/HelloActivity.java

package org.hello;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class HelloActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.hello_layout);
    }
    @Override
    public void onStart() {
        super.onStart();
        TextView textView = (TextView) findViewById(R.id.text_view);
        textView.setText("Hello world!");
    }
}

Instalação do Maven

Agora você tem um projeto que pode ser compilado com o Maven. O próximo passo é instalar o Maven.

O Maven pode ser baixado como um arquivo zip no site http://maven.apache.org/download.cgi. Apenas os binários são necessários, então procure pelo link para apache-maven-{version}-bin.zip or apache-maven-{version}-bin.tar.gz.

Baixe e descompacte o arquivo, e depois adicione o diretório bin ao seu path.

Para testar a instalação do Maven, execute mvn na linha de comando:

mvn -v

Se tudo correr bem, você deve visualizar detalhes da instalação como essas:

Apache Maven 3.2.1 (ea8b2b07643dbb1b84b6d16e1f08391b666bc1e9; 2014-02-14T11:37:52-06:00)
Maven home: /usr/local/apache-maven/apache-maven-3.2.1
Java version: 1.8.0, vendor: Oracle Corporation
Java home: /Library/Java/JavaVirtualMachines/jdk1.8.0.jdk/Contents/Home/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "mac os x", version: "10.9.2", arch: "x86_64", family: "mac"

Você agora tem o Maven instalado.

Definir um arquivo de build

Agora que o Maven foi instalado, você precisa criar uma definição para o project Maven. Você define projetos do Maven com um arquivo XML chamada pom.xml. Entre outras coisas, esse arquivo fornece o nome do projeto, versão, e dependências que ele tem para bibliotecas externas.

Crie um arquivo chamada pom.xml na raiz do seu project e salve o seguinte conteúdo nele:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.hello</groupId>
    <artifactId>gs-maven-android</artifactId>
    <version>0.1.0</version>
    <packaging>apk</packaging>
    <properties>
        <!-- use UTF-8 for everything -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.google.android</groupId>
            <artifactId>android</artifactId>
            <version>4.1.1.4</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                <artifactId>android-maven-plugin</artifactId>
                <version>3.9.0-rc.1</version>
                <configuration>
                    <sdk>
                        <platform>19</platform>
                    </sdk>
                    <deleteConflictingFiles>true</deleteConflictingFiles>
                    <undeployBeforeDeploy>true</undeployBeforeDeploy>
                </configuration>
                <extensions>true</extensions>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

O elemento <packaging> deve especificar apk. Esse é o arquivo pom.xml mais simple possivel para compilar um projeto Android. Ele inclui os seguintes detalhes da configuração do project:

<modelVersion>. versão do model POM (sempre 4.0.0).
<groupId>. Grupo ou organização na qual o projeto pertence. Frequentemente é expresso como um nome de domínio invertido.
<artifactId>. Nome a ser fornecido para o artefato do project (por exemplo, o nome do arquivo APK).
<version>. Versão do projeto que será compilado.
<packaging>. Como o projeto deve ser empacotado, nesse caso será um APK do Android.

A seção <dependencies> declara uma lista de dependências para o projeto. Especificamente, é declarado uma única dependências para a biblioteca Android. Dentro do elemento <dependency>, a dependência é definida por três sub-elementos:

<groupId>. Grupo ou organização na qual a dependência pertence.
<artifactId>. Biblioteca necessária.
<version>. Especificaa versão da biblioteca que é necessária.
<scope>. Definição do escopo como compile é o padrão. Isto é, todas as dependências devem estar disponíveis durante a compilação.

Nesse caso, o elemento <scope> foi definido com o valor provided. Dependências desse tipo são necessárias para compilar o projeto, mas serão fornecidas durante a execução por um contêiner que executa o código. Por exemplo, as APIs do Android estão sempre disponíveis quando uma aplicação Android é executada.

A seção <build> declara configurações adicionais para compilar a aplicação. Dentro dela está a seção <plugins>, que contém uma lista de plugins que adicionam funcionalidade adicional para o processo de compilação. Aqui é onde você define a configuração para o Android Maven Plugin. Como no caso das dependências, plugins também possuem elements <groupId>, <artifactId>, e <version>, e eles se comportam como descritos anteriormente. A declaração do plugin também possui esses elementos:

<configuration>. Configurações e especificas do plugin. No nosso caso, especificamos qual plataforma do SDK Android será usada.
<extensions>. Combinando a especificação do valor true e apk para <packaging> diz que o Android Maven Plugin deve estar envolvido no processo de compilação.

Nesse ponto você acabou de definir um projeto mínimo do Maven capaz de ser compilado.

Compilar o código

O Maven está agora pronto para compilar o projeto. Você pode executar diversos alvos com o Maven agora, incluindo aqueles usados para compilar o código, criar um pacote de biblioteca (como um JAR file) e instalar a biblioteca na repositório local do Maven.

Tente compilar o projeto:

mvn compile

Esse comando executa o Maven, dizendo a ele para executar o alvo compile. Quando ele terminar de fazer isso, você vai achar arquivos .class no diretório target/classes.

Por ser improvável que você queira distribuir seu trabalho e arquivos .class, você irá querer executar o alvo:

mvn package

Esse alvo compila o cogio, executa os testes, e empacota o código em um arquivo JAR dentro do diretório target. O nome do arquivo JAR é baseado nos valores de <artifactId> e <version>. Por exemplo, baseado no arquivo pom.xml mínimo criado anteriormente, o arquivo JAr será chamada gs-maven-android-0.1.0.jar.

Por causa do valor de <packaging> ser “apk”, o resultado será uma arquivo APK no diretório target, além do arquivo JAR. Esse arquivo APK é uma aplicação Android pronta para ser carregada em uma dispositivo ou emulador.

O plugin do Maven para Android fornece muito mais alves que você pode usar para iniciar diversas fases do processo de compilação, ou interagir como o dispositivo ou emulador. Você pode visualizar uma lista de alvos disponíveis executando o comando:

mvn android:help

Declarando dependências

O exemplo Hello World acima é totalmente auto-contido e não depende de bibliotecas adicionais. Muitas aplicações, porém, dependem de bibliotecas externas para lidar com funcionalidades complexas ou comuns.

Por exemplo, suponha que você queira que sua aplicação mostre a data e hora atual. Apesar de você poder usar os recursos de manipulação de data e hora nativos das bibliotecas Java, você pode tornar as coisas mais interessantes usando a bibliotecas Joda Time.

Para isso, modifique o arquivo HelloActivity.java para que fique dessa forma:

src/main/java/org/hello/HelloActivity.java

package org.hello;
import org.joda.time.LocalTime;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class HelloActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.hello_layout);
    }
    @Override
    public void onStart() {
        super.onStart();
        LocalTime currentTime = new LocalTime();
        TextView textView = (TextView) findViewById(R.id.text_view);
        textView.setText("The current local time is: " + currentTime);
    }
}

Nesse exemplo, você está usando a classe LocalTime da biblioteca Joda Time para ler e exibir a hora a atual.

Se você executar mvn package para compilar o projeto nesse momento, o processo irá falhar porque você não declarou Joda Time como uma dependência. Você pode corrigir isso, adicionando as seguintes linhas na seção <dependencies> de seu arquivo pom.xml:

<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.3</version>
</dependency>

De forma similar à dependência do Android mencionada anteriormente, esse bloco XML declara uma nova dependência ao seu projeto, especificamente a bibliotecas Joda Time.

Recompilando o código com as dependências

Agora, se você executar mvn compile ou mvn package, o Maven deve buscar a dependência para a biblioteca Joda Time do repositório Maven Central e irá compilar a aplicação sem erros.

Abaixo segue o arquivo pom.xml completo: