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 comocompile
é 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 valortrue
eapk
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:
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>
Sumário
Parabéns! Você acabou de criar um projeto Maven simples mais efetivo para compilar projetos Android.