Para seguir este tutorial você tem que ter na sua máquina.
- Java SDK 5 ou 6 (nunca testei com o 7)
- Android SDK
- Eclipse 3.5 (Galileo) ou mais recente, a versão classic dele basta
- Plugin ADT do Eclipse, plugin de android para eclipse
Caso não tenha nada disso sugiro dar olha olhada neste guia (em ingles) do próprio site do Android. Que aliás será seu maior aliado para desenvolvimento em Android.
Criando seu projeto
Em seu eclipse vá em File>New>Project..., selecione Android Project.
Em Project Name coloque OlaAndroid, clique em Next.
Agora você deve selecionar o Build Target de seu aplicativo, isto definirá a versão mínima que o seu aplicativo poderá ser executado.
Atualmente a mais de 90% dos aparelhos que existentes rodam na versão 2.2 (Froyo) ou superior, a escolha de qual será seu target é uma questão técnica. Existem algumas APIs que só estão disponíveis em versões mais recentes do Android. Um exemplo são os Live Wallpapers, os papéis de paredes animados, só foram introduzidos a partir da versão 2.1, então neste caso você não conseguiria usar um target do android 1.6 para criar Live Wallpapers.
Vale lembrar que apesar de o mais comum é utilizar o número das versões como 2.2, 2.3 ou 3.0 o mais correto no caso do Android é utilizar o API Level. Digo isto pois dentro de uma mesma versão a API pode ter sido mudada.
Por exemplo na versão 2.3 (conhecida também como Gingerbread) existem dois API Levels diferentes. A API Level 9 e 10.
Em developers.android.com você pode verificar as mudanças de cada API com mais detalhes. Neste link você pode ver as mudanças ocorridas na API 10.
Sim isto é bem confuso e se você não entendeu eu tentarei futuramente explicar melhor isto.
Neste projeto vamos escolher a 2.2.
Agora digite o nome do pacote run.nerd.talks.
 |
| Diálogo de novo projeto do Android |
E aperte finish!
Rodando seu projeto no emulador
Clique com o botão direito em seu projeto selecione Run As > Android Application.
Aparecerá uma imagem avisando que você não possui um dispositivo, selecione Yes para criarmos um emulador do Android.
Na tela acima clique em new, de um nome para seu emulador, neste caso eu dei o nome de Froyo, target 2.2 - API Level 8 e o resto dos campos eu deixei no padrão.
Clique em Create AVD.
Feche as janelas novamente e tente executar o projeto de novo, desta vez o emulador iniciará automaticamente. Você verá algo como a tela abaixo durante um tempo, não se preocupe se demorar pois infelizmente o emulador é muito lento a boa notícia é que você não precisa inicia-lo toda vez que for testar seu aplicativo por isso deixe o aberto.
 |
| Emulador iniciando, não se preocupe ele é lerdo mesmo |
Depois do emulador iniciar com sucesso ele vai automaticamente abrir seu aplicativo, você verá então algo como o seguinte.
 |
| Nosso Projeto rodando \o/ |
Alterando um pouco o código
Agora vamos dar uma olhada no código já que o próprio plugin do eclipse já se encarregou de criar o famoso Hello World para você.
A estrutura de diretórios no seu projeto deve estar algo como a imagem abaixo.
Vou explicar brevemente cada diretório
- src: é onde você colocará todo seu código fonte Java
- gen: este diretório você não precisará mexer, o próprio Eclipse+ADT se encarrega de gerar o arquivo R.Java nele contido. Explicarei mais adiante o seu conceito
- bin: é o diretório onde o seu projeto compilado ficará
- res: esse diretório é o diretório de resources, imagens, arquivos de localização, sons e layouts ficam dentro deste diretório
Vamos dar uma olhada no código do OlaAndroidActivity.java.
public class OlaAndroidActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Perceba que a classe herda de Activity, uma Activity é um dos elementos mais importantes de um aplicativo Android. Cada activity geralmente representa uma tela que cobre toda a tela do telefone, mas também pode ser um popup que cobre parcialmente a tela.
Veja que nossa Activity OlaAndroid sobrescreve o método onCreate(), este método é um método de Callback da Activity. Os outros são, onRestart(), onStart(), onResume(), onPause(), onStop() e onDestroy(), nós como programadores não temos controle sobre quando esses métodos são chamados e nem podemos impedir que eles aconteçam, todo o ciclo de vida é controlado pelo sistema operacional.
Toda vez que você navega através de seu aplicativo, por exemplo quando você abre a lista de contatos de seu telefone uma activity é executada, quando você seleciona um contato e abre os detalhes dele outra activity é executada e a anterior fica "pausada" mas pode ser até destruída caso o sistema precise de memória.
É importante ter isso em mente ao criar suas Activities.
Na linha 5 veja que é o método equivalente da classe pai é chamado, é importante lembrar que o método da superclasse deve SEMPRE ser chamado antes que você execute qualquer código seu.
Na linha 6 há dois pontos importantes, primeiro está sendo definido qual é o arquivo de layout de sua activity e como parâmetro estamos usando a classe R, esta classe é gerada automaticamente pelo android e se encontra no diretório gen de seu projeto. O R representa todos os resources de seu projeto, desde os layouts até as músicas e os IDs que você declara para os elementos de seu layout você irá acessá-los através do R.
Neste caso estamos definindo que o nossa activity usará o layout main. Vá até o diretório res/layout/main.xml e abra-o.
No canto superior direito veja que tem dois select boxes, um está selecionado como any locale e outro como Android 3.0, mesmo nosso target sendo o 2.2 é preferível usar a renderização do 3.0 pois o preview é melhor que as versões antigas.
Esse editor é no estilo WYSIWYG mas eu particularmente não gosto muito dele, é interessante pois é possível ver os componentes já existentes.
O Android já tem um punhado de componentes prontos que facilitam bastante na hora de criar aplicativos.
Caso, como eu, prefira criar os layouts digitando o xml na parte inferior clique na aba main.xml.
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello" /> </LinearLayout>
Sinto muito dar esta notícia, mas criar layouts em Android não é parecido com nada que eu ou possivelmente você conheça, mas te digo que não é um bicho de sete cabeças, é mais fácil que swing no Java por exemplo :).
Os elementos gráficos no Android são chamado de Views, a classe android.view.View é o elemento básico de componentes gráficos em Android, todas os objetos gráficos são uma subclasse de View
No exemplo atual temos duas views uma chamada LinearLayout e outra chamada TextView
Na linha 2 está a declaração do LinearLayout, LinearLayout é uma subclasse de ViewGroup como o nome sugere uma ViewGroup é um tipo especial de View que tem outras Views como seus "filhos".
Um LinearLayout vai ordenar seus filhos de maneira, pasmem, linear! Pode ser tanto na horizontal android:orientation="horizontal", ou vertical android:orientation="vertical".
Na linha 6 temos outra View agora do tipo TextView, veja que ela está declarada dentro do LinearLayout, um TextView quem diria serve para exibir textos no Android.
O texto a ser exibido por um TextView pode ser definido programaticamente ou descrito no próprio xml usando a propriedade android:text, no código gerado o valor definido é @string/hello, essa é a maneira do android para se fazer a referência para o arquivo de localização, vamos abri-lo segurando o Control (ou command se tiver no mac) e clicando sobre o texto @string/hello, ou se preferir ele está em /res/values/strings.xml.
<?xml version="1.0" encoding="utf-8"?> <resources> <string name="hello">Hello World, OlaAndroidActivity!</string> <string name="app_name">OlaAndroid</string> </resources>
Bom agora acho que fica um pouco mais claro como a macumba, digo mágica acontece. Vamos então ao ...
Mãos a obra! Hands to the work!
Abra novamente o arquivo main.xml
Primeiro vamos alterar o android:layout_width de fill_parent para wrap_content no TextView. Quando este parametro é atribuído com fill_parent a largura da view será igual a largura disponível no pai, se colocar wrap_content a largura será igual a largura do conteúdo da view.
Abaixo dessa TextView vamos adicionar uma View ao nosso Layout, coloque após o TextView um Button
<Button android:id="@+id/helloButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="linha ou coluna"/>
Seu arquivo final ficará assim.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="horizontal" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello" />
<Button android:id="@+id/helloButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="linha ou coluna"/>
</LinearLayout>
Rode o projeto e você vera ele assim.
Vamos alterar agora o android:orientation de vertical para horizontal e executar novamente o projeto, lembre-se não é necessário reiniciar o emulador
E agora seu botão foi colocado ao lado do texto.
Perceba que nosso botão possui um parametro id que está definido com "@+id/helloButton", nossa view agora possui um id helloButton que foi criado automaticamente no R de nosso projeto.
Abra novamente o OlaAndroidActivity.java, se quiser mais uma hotkey aperte [windows = control+shift+r] ou mac [command+shift+r] digite o nome do arquivo e de enter.
Vamos colocar um listener em nosso botão que vai alterar o texto do próprio botão. Sua activity ficará deve ficar como abaixo
private Button helloButton;
private int counter = 0;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
helloButton = (Button) findViewById(R.id.helloButton);
helloButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
helloButton.setText("clicou "+counter++);
}
});
}
Na linha 9 primeiro precisamos da instância do botão que está em nosso layout, para isso usamos o método findViewById passando como parametro o id de nossa view, isso retornará a instância do objeto que está renderizado na tela.
Na linha 10 até a linha 14 implementamos um onClickListener que alterará o texto do botão mostrando um contador de quantas vezes o botão foi apertado
Após apertar o botão seu aplicativo deverá parecer algo com o que está abaixo.
Pronto agora você sabe algumas coisas básicas do Android e poderá se aventurar mais na plataforma, espero que com esse post seja possível ter um apanhado mais básico de como o Android funciona.
Ele acabou ficando maior que eu imaginava e ainda acho que falta muito para explicar, pretendo continuar com essa série de posts sobre android focando em temas mais específicos a partir de agora.
Os sites que mais utilizo como material de referencia e para aprender o Android são os seguintes:
developer.android.com
stackoverflow.com
O código fonte do projeto pode ser encontrado no git hub.
https://github.com/diegoy/OlaAndroid
Obrigado, se tiverem dúvidas, sugestões de melhoria do post atual ou até temas para próximos posts me avise nos comentários.
Valeu!
