Sumário
1 Project Wizard 31.1 Informações importantes 5
1.1.1 Project name (Nome do Projeto) 5
1.1.2 Contents (Conteúdo) 5
1.1.3 Build Target (“Plataforma Padrão”) 5
1.2 Target Name (“Nome da Plataforma”) 7
1.2.1 Vendor (Distribuidor) 7
1.2.2 Platform (Plataforma) 7
1.2.3 API Level (Level da Interface de Programação) 7
2 Configurando o Projeto 8
2.1 Application name (Nome da aplicação) 8
2.2 Package name (‘namespace’) 8
2.3 Create Activity (“Criar atividade ‘main’”) 8
2.4 Min SDK Version 9
3 Compreendendo melhor o Android Project 10
3.1 SRC 10
3.2 Gen 11
3.3 SDK 12
3.4 Assets 12
3.5 Res 13
3.5.1 Drawable 13
3.5.2 Values e Layout 14
4 Manifesto 16
5 A Atividade! 19
6 Revisando 21
7 Links
Hello World
1 Project Wizard
Decidi-me por fazer um Hello World, pois é a aplicação mais simples que se pode fazer em uma plataforma e que muitas vezes mostra a utilização, de forma básica e essencial, dos componentes de construção primitivos.
Posteriormente é importante ressaltar que utilizaremos o Eclipse para esta finalidade, pela facilidade que o mesmo nos traz. E com o advento do pluging ADT fica mais simples e prático publicar as aplicações.
Comecemos “estartando” a nossa IDE Helios com o Plugin ADT. Na tela que abre, abaixo dos menus que estão abaixo da barra de títulos procure o ícone . Clique na seta ao lado e, considerando que já esteja com o ADT instalado, selecione a opção Project.... Após selecionar a opção, a janela a seguir parecerá:
Figura 1 – Tela para Seleção de Wizard.
Na tela, selecione Android Project. Após selecionar a opção o wizard a seguir deverá ser apresentado:
Figura 2 - Wizard do Novo Projeto Android.
1.1 Informações importantes
1.1.1 Project name (Nome do Projeto)
O nome que será apresentado dentro do workspace do eclipse. No nosso caso é o sugestivo ‘Hello World’;
1.1.2 Contents (Conteúdo)
Defini se o projeto será iniciado a partir de código novo ou se baseará em algum já existente.
1.1.3 Build Target (“Plataforma Padrão”)
Este campo tem informações importantes para serem compreendidas. Nesta tabela com 6 (seis) itens, no nosso caso, são enumeradas as SDKs instaladas em meu sistema operacional, através da ferramenta “Android SDK and AVD Manager”. Depois de instalada e configurada no pluging ADT dentro do Eclipse Helios, poderá ser acessada pelo menu da barra de menus Window (Janela), como o mostrado na Figura 3 mais abaixo.
Figura 3 - Acesso da ferramento Android SDK and AVD Manager pelo menu Window.
1.2 Target Name (“Nome da Plataforma”)
Ainda falando sobre a tabela com as versões distintas de SDKs instaladas, temos os campos Target Name, Vendor, Platform e API... (API Level). Sobre o primeiro campo, Target Name, é o nome dado para uma plataforma específica. Neste caso a plataforma de nome ‘Android 2.1 – update 1’ está selecionada para pronto uso.
1.2.1 Vendor (Distribuidor)
Já a coluna Vendor corresponde ao distribuidor desta SDK, ou API. Esta ultima coluna citada é necessária, pois há possibilidade de utilizar APIs customizadas, até porque Android é detentor de licença de código aberto e o mesmo poderá ser modificado por terceiros e posteriormente utilizado por você.
1.2.2 Platform (Plataforma)
Tratando da próxima coluna: Platform, é esta a responsável por indicar qual plataforma Google Android, propriamente dita, está sendo utilizada pela API.
1.2.3 API Level (Level da Interface de Programação)
Já API Leve é um campo que detém informação para facilitar a compatibilidade através das várias Plataformas (correspondidas pelo campo Platform). Esse número é utilizado pela versão de Android instalada em um dispositivo para validar a compatibilidade do software a ser instalado.
A cada plataforma distinta é dado um valor incremental distinto, tornando-o um identificador. Este identificador acusa a versão da aplicação para a plataforma, a mesma verifica o número para validar correspondência ou se o número é menor ao identificador da plataforma. Assim sendo, o aplicativo poderá ser instalado, pois corresponde a todos os requisitos da API nativa.
Esse mesmo identificador poderá ser utilizado pelo Google Android Market para evitar que um aplicativo seja baixado por um dispositivo inadequado. Assim sendo, o dispositivo acessa o Market, não visualiza o aplicativo, não baixa e consequentemente não irá falar mal de quem o fez.
2 Configurando o Projeto
2.1 Application name (Nome da aplicação)
Depois de escolher a API e a que Plataforma a mesma se refere (API Level 7, no nosso caso), é hora de configurar as propriedades do projeto. Primeiro vem o nome (Application name) a que sua aplicação irá ser referenciada, no nosso caso: Olá Mundo.
2.2 Package name (‘namespace’)
Logo após o nome, a informação a ser inserida é o nome do pacote (Package name) que será contido dentro da aplicação, onde seus componentes estarão inseridos. Aqui eu configurei como “examples.olamundo” para ficar sugestivo.
2.3 Create Activity (“Criar atividade ‘main’”)
Após essas duas informações vocês verão uma ‘check box’ seguida de um ‘text field’. Esta check box é para indicar se, de início, você configurará uma Atividade para ser a Main Activity, ou seja, seu ponto de partida na aplicação. Veremos isso de uma forma mais coerente quando analisarmos o manifesto.
2.4 Min SDK Version
Finalmente, há o código de compatibilidade com a plataforma a ser utilizada por sua aplicação. Lembrando que este código é utilizado pela Plataforma do dispositivo a rodar a aplicação como forma de manter a compatibilidade entre os recursos utilizados e os contidos neste.
Como observação deixo: que estarei utilizando a Plataforma de código 7, pois o meu celular Motorolla XT 300 Spice (espero trocá-lo logo) a utiliza. Entretanto, fiquem livres para utilizarem a SDK que bem desejarem, observando que a diferença entre uma e outra é a maior quantidade de recursos; recursos esses que variam da otimização de componentes até a elaboração de componentes que viabilizem a maior compatibilidade da aplicação com os diversos tamanhos de telas disponíveis no mercado.
Voltando ao assunto anterior, configuração do projeto Android, no wizard em que estávamos, apertem o botão “finish”.
3 Compreendendo melhor o Android Project
3.1 SRC
Figura 4 - Raiz do Android Project.
Como podem ver um projeto Android não é tão simples. Ele detém alguns diretórios cada qual com sua utilidade específica. Primeiramente, o diretório ‘src’, com o pacote padrão do nosso projeto, detém todos os códigos fontes da aplicação.
A especialidade do pacote padrão, configurado no wizard do projeto, é indicar o ‘namespace’ o qual é utilizado como referência dentro do manifesto como forma de indicar à plataforma o repositório padrão, como o nome já diz, dos códigos dos blocos de construção primitivos. Com a finalização do wizard o manifesto é gerado a partir dos dados configurados através dele e consequentemente a informação do ‘namespace’.
3.2 Gen
Adiante há o diretório de código gerado. Este código não é gerado pelo programador e sim pela própria SDK da plataforma. Este código não deve ser alterado em hipótese alguma de forma direta. A classe R.java é uma classe utilizada pela plataforma para deter referência a todos os componentes no contexto da visão.
Figura 5 - Classe R (Platform Generated).
Como podem ver, a Classe R é ‘final’, para inviabilizar uma especialização por parte do programador e desta forma gerar alguma inconformidade. A mesma contém classes internas as quais detêm as referências do contexto da visão. Todos esses valores, na forma de atributos das classes internas, referem-se a componentes que poderão ser utilizados por uma Atividade para a apresentação.
Cada Classe Interna desta mantém informações de forma organizacional. Veremos que quem define em qual classe interna cada componente deverá ser referenciado ou a necessidade de novas classes para facilitar a organização é o próprio desenvolvedor, mas seguir um padrão tem as suas vantagens. Uma delas é a facilidade em que temos para identificar a utilidade de cada componente em específico. Portanto, seguir essa lógica organizacional que a própria plataforma definiu há vantagens.
3.3 SDK
Descendo um pouco mais, temos o .jar da SDK em questão (level 7, em meu caso). Se abrirem este .jar verão vários pacotes, cada qual com uma quantidade variável de classes e interfaces. Se prestarem um pouco mais atenção, verão que há pacotes referentes à API Java. Boa parte da mesma é reutilizada nos projetos Android, e de quebra a codificação nessa plataforma recebe todos os adventos da sintaxe Java (inclusive Generics, Varargs, modificadores de visibilidade, tipos primitivos e tipos por referência – Boolean, boolean, Integer, int, Double, double, Float, Float, BigDecimal -, etc).
3.4 Assets
Mas abaixo, no diretório ‘assets’, é o local onde os arquivos aqui posicionados são referenciados, dentro do pacote .apk compilado do Projeto Android, por URIs (o qual funciona como um identificador unificado de fontes; especificação como os mesmos devem ser referenciados dentro dos diretórios - navegação). O que isso significa? Basicamente, significa que a Plataforma trata os arquivos aqui salvos de maneira diferenciada aos salvos no diretório ‘res’, onde os mesmos são manipulados utilizando-se a classe R.
3.5 Res
3.5.1 Drawable
Figura 6 - Diretório 'res'
Aproveitando a deixa, iremos ao diretório ‘res’, onde temos todos os resources que são mantidos pelos componentes de construção primitivos da Plataforma, mais propriamente dito, pelas Atividades. São nas três pastas de drawables guardadas as imagens de alta, média e baixa densidades (hdpi – High Dots Per Inch, mdpi – Medium Dots Per Inch e ldpi – Low Dots Per Inch). Verifiquem que na Figura 6 temos três icon.png e que na Figura 5 temos a uma única referência, dentro da classe interna drawable. Isso ocorre, pois a plataforma Android, em tempo de execução, decide qual é a melhor imagem, a mais adequada, para a densidade necessária, portanto, justificando a utilização de uma única referência.
3.5.2 Values e Layout
Figura 7 - Arquivo 'string.xml'
Figura 8 - Arquivo 'main.xml'
Values é o diretório reservado para armazenar valores referentes a Strings ou lista de Strings. Já o diretório Layout – bem sugestivo – armazena os componentes gráficos capazes de serem ‘renderisados’ pelas Atividades.
Como podem ver, no arquivo ‘string.xml’, na Figura 7, são declarados dois valores: “hello” e “app_name”. Os mesmos são nada mais do que dois objetos String utilizados como forma de adquirir organização dentro do projeto Android. Desta forma, toda vez que for necessário utilizar o valor ‘Hello World, Hello World!’ uma referência a “hello” será feita. Da mesma forma, toda vez que for necessário utilizar o valor ‘Olá Mundo’ uma referência a “app_name” será utilizada.
Como o projeto foi criado a partir de um wizard do pluging ADT, por padrão, ele configura “app_name” com o nome (identificador) definido para a aplicação. E também configura uma String padrão de todo projeto recém-criado: “hello”, a qual é utilizada para apresentar uma mensagem em um componente ‘TextView’ – Figura 8.
Verifiquem que a referência ao componente String do arquivo ‘string.xml’ é mantido no arquivo ‘main.xml’ desta forma: “@string/hello”. Toda vez que o símbolo ‘@’ for visto, infere-se uma referência a algum componente inserido em algum arquivo XML. E se observarem melhor, identificarão que ‘string’ é uma classe interna de ‘R.java’ e que ‘hello’ é um membro da mesma. Portanto, infere-se, ainda, que esse componente poderá ser referenciado em um código Java (forma programática).
Focando melhor no arquivo ‘main.xml’, identificaremos alguns elementos básicos. Primeiramente o cabeçalho que todo documento XML deverá ter, indicado pela tag ‘’. Dentro da mesma, há a versão do documento XML utilizado – “1.0” – e a forma de decodificação dos caracteres empregados no mesmo documento – “utf-8”.
Após o cabeçalho do documento há uma tag ‘
Além da tag ‘’ ser obrigatória, o “namespace”, necessariamente, deverá ser empregado dentro do componente na raiz da hierarquia de componentes da visão, ou seja, o “pai de todos”, que no nosso caso é identificado pela tag ‘
A partir do momento em que prosseguirem e experimentarem a Plataforma, criarão seus próprios componentes e identificarão seus próprios ‘namespaces’.
Adiante não explicarei mais esse documento, pois além de ser bem intuitivo, está reduzido em quantidade de componentes e propriedades.
4 Manifesto
Figura 9 - AndroidManifest.xml
Neste momento, apresento a vocês: O Manifesto! O arquivo de configuração de sua aplicação Android. Como o visto na Figura 9, o documento tem dois detalhes já explicados quando falei do arquivo ‘main.xml’: a tag ‘’ e o ‘namespace’.
Adentrando à tag ‘
Já a propriedade ‘versionName’ é a versão de apresentação. É a versão a qual um suposto usuário irá utilizar para se orientar. Por exemplo: em algumas empresas a versão de um pacote de software é identificada da seguinte maneira: o primeiro número antes do ponto significa a versão de lançamento do software, enquanto o segundo número após o ponto significa quantas atualizações aquele software sofre e um suposto terceiro número significa o número da versão de teste do mesmo pacote. Mas esta orientação é um padrão nominal definido cada qual de sua maneira própria. Portanto, a Plataforma não mantém este número com intuito de manter o software atualizado e sim como forma de apresentação da versão do produto. Desta maneira, somente ‘versionCode’ será utilizada no intuito de manter o produto atualizado.
Concluindo a tag ‘
Adiantando ainda mais, mais uma novidade: a tag ‘
De acordo com o comentado, entre as tags de abertura e fechamento de ‘application’ há a declaração do componente Atividade a ser utilizado, por intermédio da tag ‘
Caminhando para as entrelinhas, dentro do corpo de ‘activity está presente a tag ‘
Esses ‘Intents’ são as mensagens mandadas para o Sistema Operacional com intuito de iniciarem componentes de construção primitivos. Entretanto, em alguns casos, não basta somente indicar um componente, mas dizer como o mesmo será utilizado e como o mesmo será encontrado. Deste modo, ‘action’ diz o momento exato em que a Atividade será iniciada, dentro do nosso contexto, e ‘category’ indica a especialidade a qual esse componente deverá ter.
Para quem achou núbio: a propriedade ‘name’ de nossa tag ‘action’ indica qual é a ação que determina o momento exato em que a nossa Atividade será instanciada. Desta maneira, toda vez que a aplicação for selecionada, a plataforma receberá uma informação (Intent), a qual indica que evento o qual iniciou esta mensagem é um evento de requisição de aplicação – que no caso pode ser a HelloWorld!.
Esta mensagem de requisição contém algumas informações para que seja interpretada como tal: primeiramente a mesma contém dizendo o momento em que deverá o componente ser inicializado (momento inicial: ‘MAIN’); contém também a informação de como o componente será utilizado (como a primeira Atividade da stack da aplicação: ‘LAUCHER’) e, como essa mensagem é enviada a partir de um método ‘startActivity’, que deverá inicializar um componente Atividade.
Entretanto alguns estarão se perguntando como o OS identifica a Atividade correta sem implicar momento algum em seu nome. Por isso que existe a estrutura de que estamos falando: ‘filtro de intenções’ (‘intent-filter’). Pois, de acordo com as especificações de momento (‘action’) e funcionalidade (‘category’), ela procura o componente o qual se adequa a informação interpretada em tempo de execução. Como nossa aplicação só tem uma declaração, para a Plataforma é fácil, entretanto se houvesse duas Atividades com as mesmas atribuições de momento e funcionalidade, Android ‘estartaria’ a primeira declarada, neste caso, pois se trata de uma mensagem filtrada dentro da mesma aplicação. No caso da mensagem ser filtrada entre aplicações diferentes, a mesma perguntaria para o usuário qual aplicação deveria ser ‘estartada’. Isso ocorre quando temos aplicações utilizando as mesmas informações como filtro, portanto caracterizando as mesmas funcionalidades nas duas aplicações; ex.: dois gerenciadores de pastas.
Portanto, com a seleção do ícone o qual contém o nome da aplicação e através do pacote padrão, o Sistema consegue identificar onde buscar os componentes, já com a ação consegue indicar quando buscar e com a categoria consegue identificar como deverá inicializar este.
5 A Atividade!
Figura 10 - Atividade HellowWorld.
Como o de costume: declaração do pacote em questão como cabeçalho de nosso documento .java. Necessariamente, este deve ser a primeira declaração a ser feita em um documento deste. Após isso, há dois ‘imports’: “android.app.Activity” e “ android.os.Bundle”. Activity, como podem imaginar, é utilizada para identificar a classe pública ‘HelloWorld’ como uma Atividade, um bloco de construção primitivo para apresentação. Já, ‘Bundle’ é um recurso utilizado pela Plataforma para conseguir emitir mensagens top-down e down-top entre os diferentes níveis e camadas presentes nessa. Bundle é utilizado tanto para enviar mensagens extras para outras Atividades, quanto para salvar o estado da mesma, com o intuito de recuperá-lo posteriormente.
Também, como o de costume: há a declaração da classe ‘HelloWorld’ estendendo de ‘Activity’, logo, a classe é considerada uma Atividade, pois em qualquer lugar que ‘Activity’ pode ser utilizada, ‘HelloWorld’ também poderá (POLIMORFISMO).
Entrando na classe, para quem não conhece ‘Annotations’, anotações geralmente são utilizadas para configuração de Classes e seus membros. ‘Annotations’, frequentemente, é recurso utilizado de forma alternativa às configurações em documento XML, agregando a configuração juntamente ao código. Nesse caso, a anotação ‘@Override’ é só uma forma de garantir que o método ‘onCreate’ será realmente uma sobrescrita de um método presente em ‘Activity’. Esse nível de “Anotação” é vinculado como forma de manter integridade do código produzido, pois se o método “anotado” não corresponder a uma assinatura válida na classe ‘Activity’, a mesma não chega a ser compilada.
Posteriormente temos o método ‘onCreate’, o qual determina o início do ciclo de vida da Atividade. Tem um parâmetro ‘Bundle’ para um caso já comentado: recuperar o estado anteriormente salvo. O mesmo método executa o do pai para que este se responsabilize por restaurar o estado de acordo com o objeto ‘Bundle’.
Com supostos estados carregados, o método executa uma ultima chamada: ‘setContentView’, o qual se utiliza de um valor declarado dentro de ‘R.class’. Se prestarem atenção, compreenderão que neste momento a Atividade está se utilizando indiretamente de um documento XML já criado anteriormente, o documento ‘main.xml’. Dentro desse tínhamos componentes visuais para a apresentação de uma mensagem definida dentro de um objeto ‘String’, presente no documento ‘string.xml’. E que é notório o mecanismo de busca do documento não referenciar ao XML de forma direta, pois tudo dentro de ‘res’ será recuperado através da classe ‘R’ e seus membros.
Portanto, neste devido momento, já devem estar imaginando o que aparecerá na tela e a forma em que aparecerá. Como o especificado no manifesto: barra de título com o valor “Olá Mundo”; como o especificado no documento ‘string.xml’, reutilizado no documento ‘main.xml’ o qual é referenciado pela Classe ‘R’, ‘hello’ apresenta o valor “Hello World, HelloWorld!”. Desta forma concluindo o básico do básico sobre mecanismos do Sistema Operacional.
Figura 11 - AVD da aplicação Olá Mundo.
6 Revisando
Determinamos o manifesto da aplicação como sendo o documento de configuração. Dentro do mesmo contém as informações de componentes e como esses serão inicializados pelo Contexto da Plataforma. Entende-se por Contexto o momento em que se tem contato com algo. Portanto, a menos que interceptamos o ciclo de vida de um componente, o Contexto define a criação, operação e “destruição” de um componente.
Dentro do manifesto vimos que determinamos os filtros pelos quais os componentes em específico serão identificados para poderem ser instanciados. Entretanto, lembrem-se que não há só a forma genérica (por ‘action’ e ‘category’) para ‘estartar’ um componente, mas a forma específica na qual é indicado o componente por seu nome completamente qualificado, o qual é composto por ‘namespace’ e nome do componente em questão.
Entendemos os mecanismos de inicialização de uma Atividade, e consequentemente de outros componentes. Vimos que uma Atividade não é gerenciada pelo usuário, a menos que o mesmo intercepte o ciclo de vida da mesma.
Vimos que algumas fontes são recuperadas através da classe ‘R’ e que na mesma não deveremos mexer, pois é gerada a partir da SDK. Vimos que temos recursos associados ao diretório ‘assets’ os quais são recuperados com as restrições de formato.
Basicamente é isso, galera. Espero que tenham gostado e que se habituem a criticarem o blog, espero que de forma sempre construtiva. Não que eu esteja desmotivado, pois eu sou muito apaixonado por Android, mas quem quiser fazer elogios e dizer o que tem mais gostado no Blog também ajuda.
Grato e que Deus nos abençoe!
Links
Para quem quizer os materiais para guardar, segue alguns links:
Google Docs Links










