Além do Hello World

Olá a todos.
Como vimos no post anterior, criamos uma aplicação simples, sem nada diferente do que o Eclipse já nos cria sozinho.
Nest post, entramos mais a fundo de um projeto Android.

Hierarquia de pastas e arquivos de um projeto Android.

 Dentro da pasta do projeto, a HelloWorld existe uma pasta chamda src, é nela que os códigos fonte do Android ficaram.
Observem que o arquivo HelloWorld.java, que escolhemos na Create Activity fica dentro do pacote com.example.helloworld, que escolhemos em Package Activity na tela de criação dos projetos.
Esta classe, que escolhemos como Activity, será a classe que será chamada assim que a aplicação for iniciada, é nela que irá conter as primeiras instruções do que a aplicação deverá fazer.

package com.example.helloworld;

import android.app.Activity;
import android.os.Bundle;

public class HelloWorld extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) { // (1)
        super.onCreate(savedInstanceState); // (2)
        setContentView(R.layout.main); // (3)
    }
}

Como descrito acima, a classe contém o nome do pacote que ela pertence, seguido dos imports que ela precisa, seguindo os padrões Java.
Diferentemente das aplicações comuns de Java, toda classe para aplicação Android deve ser derivada da classe Activity (Atividade), que possui como método pricnipal, o método onCreate (1).
Este método invoca o método onCreate da super classe passando o mesmo parâmetro que foi passado para ele, o savedInstanceState.(2)
Depois, ele chama o método setContentView() (3). Este método é responsável por exibir a tela da aplicação, que está baseada no layout xml, que por padrão é o arquivo main.xml que está em /res/layout/main.xml.

Dentro também do projeto, temos uma pasta chamada res, onde ficam armazenados todos os recursos utilizados pela aplicação. Dentro desta pasta, existem mais três diretórios que irei explicar abaixo:

•  Drawable
• Este diretório visa armazenar todas as imagens que serão usadas na aplicação. Por padrão, ele tem uma imagem chamada icon.png, que corresponde ao ícone da aplicação (que aparecerá no aparelho).
• Layout
• Este diretório armazenará todos os XMLs que correspondem ao layout da aplicação. Estes XMLs contém quais componentes serão exibidos, suas dimensões, cores, fontes e etc. Por padrão, o layout principal é o main.xml. Mais para frente vamos analisar o código deste XML.
• Values
• Este diretório irá armazenar todos os valores estáticos que podem ser utilizados no layout da aplicação (arquivos XMLs). Estes valores pré-definidos são Strings, cores, estilos e etc.

Para saber mais sobre estes diretórios, acesse:
Drawable: http://developer.android.com/guide/topics/resources/drawable-resource.html
Layout: http://developer.android.com/guide/topics/resources/layout-resource.html
Values: http://developer.android.com/guide/topics/resources/string-resource.html ou http://developer.android.com/guide/topics/resources/style-resource.html ou http://developer.android.com/guide/topics/resources/more-resources.html

 Layout main.xml
 

    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >

    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello" />

O código XML é bem parecido com um HTML, onde temos chaves e seus valores dentro das chaves.
A primeira linha, está apenas definindo que é um código xml, nada mais.
Na segunda linha, abrimos as chaves do <LinearLayout> , que indica que o nosso layout (nossa tela) organizará exibições em uma única coluna e seus componentes serão dispostos verticalmente. (Veremos mais relações de disposição da tela em outro Post).
O que defini isso é o atributo android:orientation="vertical".
Também temos nesta tag, os atributos android:layout_width e android:layout_height que estão com os valores
fill_parent que indica que ele o layout deve preencher toda a tela.
Já a tag <TextView> defini que será exibido um texto na tela. Assim como no LinearLayout, ele tem o android:layout_width="fill_parent" que indica que sua largura irá até o fim da tela, já o android:layout_height="wrap_content" indica que a altura do componente será "flexivel", e do tamanho do texto e não ocupado a tela inteira, no caso.
O campo android:text="@string/hello" indica qual é o texto que será exibido na tela, porém, ele possui um identificador de String, e seu valor mesmo está salvo em um arquivo chamado strings.xml, que iremos ver a seguir.

Arquivo strings.xml

    Hello World, HelloWorld!
    Hello World

Como toda XML, ele começa com apenas uma identificação na primeira linha.
Devemos apenas nos atentar no momento, que ele possui duas Strings pré-definidas, a hello e a app_name, e seus respectivos valores.
A String que possui como identificador hello, está sendo usada no arquivo que vimos anteriormente. Quando o XML de layout identifica uma chama @string/hello, ele irá até o arquivo strings.xml e procurará alguma chave com este identificador e irá pegar o seu valor.
Este conceito se chama Externalizar Strings bastante usado por aplicações Java e etc.
Por que eu deveria externalizar uma String? Fazemos isso quando é necessário usar o mesmo texto em vários lugares, como por exemplo, o nome da aplicação. Sendo assim, alteramos todas as Stirngs apenas neste arquivo.
Outro forte motivo, é para quando desejamos ter uma aplicação em vários idiomas, sendo assim, fazemos vários arquivos de Strings e chamamos cada um deles, conforme for a linguagem definida pelo usuário do celular, por exemplo. (Criaremos um post sobre como deixar a mesma aplicação em vários idiomas para mais frente).


AndroidManifest.xml

      package="com.example.helloworld"
      android:versionCode="1"
      android:versionName="1.0">
    
        
                  android:label="@string/app_name">
            
                
                
            
        
     

Este arquivo é o coração de uma aplicação Android. É nele que vamos configurar qual classe ele deverá chamar quando iniciar a aplicação, qual o ícone da aplicação, quais as permissões que a aplicação poderá ter entre outras coisas.
Vamos detalhá-lo um pouco para você:
Uma <activity> contém informações sobre as páginas que estarão presentes na aplicação, ou melhor, cada <activity> é uma classe Android que ele irá chamar. E dentro desta tag, vemos as propriedades como qual classe ele corresponde, seu Label (título da aplicação) e etc.

Para mais informações: http://developer.android.com/guide/topics/manifest/manifest-intro.html

Além destes importantes arquivos, temos o R.java que não pode ser modificado manualmente, é apenas modificado automaticamente, quando ocorre alguma mudança nos arquivos XMLS.
Este arquivo é responsável por registrar os componentes armazenados nos XMLs que vimos acima e com isso, podemos acessá-los, modificá-los e utilizá-los no código Java atráves desta classe.
Como por exemplo, na nossa classe inicial HelloWorld.java, quando invocamos o método setContentView() que serve para indicarmos qual tela/layout será usado quando esta classe for chamada, passamos como parâmetro R.layout.main, que nos diz basicamente "quero indicar aqui o arquivo main da pasta layout".

Neste post esclarecemos qual é a função de cada arquivo.
Agora você tem uma noção melhor do que cada um deles pode fazer e você também poderá alterar como quiser sua aplicação. Fique a vontade para descobrir este novo mundo, o Android. :)