quinta-feira, 30 de junho de 2011

Hello World!

Sumário

1 Project Wizard 3
1.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 ‘’, a qual identifica um componente visual, um contêiner de outros componentes visuais. Este contêiner organiza os componentes filhos de forma linear, ou seja, em uma só orientação; ou horizontal (padrão) ou vertical. No caso prático a propriedade ‘orientation’ foi utilizada com o valor “vertical”.

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 ‘’. Nesse exemplo o ‘namespace’ foi configurado como “android”, entretanto poderia ter sido atribuído qualquer outro valor – “a”, por exemplo. Já o ‘namespace’, propriamente dito, é o identificador de onde os componentes e a sintaxe dos mesmos deverão ser resgatados, para que assim o seu documento XML seja bem formatado.

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 ‘’ temos a propriedade ‘package’, a qual define o pacote padrão da aplicação, aquele responsável por adequar todos os códigos fontes de uma aplicação Android. Após essa, temos a propriedade ‘versionCode’, utilizado para o controle de versão da aplicação Android. É esta propriedade que identifica se uma versão é mais recente do que outra.

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 ‘’, prosseguiremos até a tag ‘’, detentora da propriedade ‘minSdkVersion’ com valor “7”. O conjunto tag, propriedade e valor, não são mais do que o reflexo do valor configurado ao campo ‘Min SDK Version’ no wizard de criação do projeto Android. Logo, o explicado para tal situação é válido para esta também.

Adiantando ainda mais, mais uma novidade: a tag ‘’. A partir desta os componentes da aplicação se tornam públicos. Sem a mesma a Plataforma do dispositivo a executar a aplicação não seria capaz de identificar os componentes a serem utilizados pela mesma. Além de conter a declaração de componentes, essa define o ícone a representar a aplicação no menu de aplicações e o nome pelo qual a mesma será referenciada, respectivamente, identificados pelas propriedade ‘icon’ e ‘name’.

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 ‘’. Através dela, a tag, são configuradas as propriedades ‘name’ e ‘label’. ‘name’ é utilizada para expor o nome das classes as quais estendem de ‘Activity’, enquanto ‘label’ define o “rótulo” da Atividade, ou seja, o texto a ser apresentado no canto superior da tela; na barra de título, por assim dizer.

Caminhando para as entrelinhas, dentro do corpo de ‘activity está presente a tag ‘’, a qual adequa a especificação do tipo de mensagem que ‘estartará’ o componente ‘Activity’ da tag superior. O que isso significa? Simplesmente que uma atividade sempre será instanciada pelo contexto da Plataforma do dispositivo em questão, ou seja, grosseiramente falando, você nunca dará um ‘new’ em uma Atividade, pois esta obrigação é delegada ao Android. Delegação essa expressa pela utilização de ‘Intents’.

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:

Windows Live SkyDrive

Google Docs Links

Só Artigo

Artigo e Imagem

Só Imagem

sábado, 23 de abril de 2011

Entendendo Melhor a Plataforma

    Considerando que todos aprenderam que a Plataforma é composta por um Kernel Linux 2.6, que este Kernel é responsável por gerenciar toda plataforma mobile, que esta se utiliza dos conceitos empregados em Processos e Usuários Linux para permitir que suas aplicações nunca entrem em conflito, que todas as suas aplicações têm uma máquina virtual própria e que suas aplicações são compostas pelos blocos primitivos de construção de Android os quais entendem o funcionamento, porém não o mecanismo; seguiremos em frente.

    Esclarecerei que não tive muito tempo para fazer este material, porém tentarei enviar outro logo – amanhã, bem provável. Fiz cobertura de detalhes essenciais para o entendimento da Plataforma. Como tudo em Android é feito para ser modularizado e funcionar de forma a criar uma interface entre os componentes de forma bem semelhante em diversos momentos, não cobri alguns componentes, deixando explicito que a abordagem tomada para Activities é semelhante para Broadcast Receivers e Services, entretanto há diferenças e essas rondam os nomes utilizados em um método e outro ou a finalidade do uso de um componente e outro. Porém este final de semana eu não tive tempo e acabei por deixa Content Providers fora de foco por enquanto, pois já tratam de um passo adiante no desenvolvimento das aplicações. Peço desculpas e compreensão. Assim, seguiremos.

  1. Backstack
  2. Até então já se tornou possível identificar mais ou menos como a Plataforma reage quanto aos seus componentes, então entraremos em uma parte importante para compreender os mecanismos do Android: a pilha de execução.

    Toda e qualquer aplicação em Android contém a sua própria pilha, até que o usuário da Plataforma torne necessária a criação de fluxos alternativos de execução. Todo programa é executado dentro do um único processo, até que, dentro de um programa, se torne necessária a criação de um segundo processo para melhor desempenho ou por decisão de modelagem.

    A Figura 1 mostra como funciona o mecanismo da pilha de execução em Android. Identifiquem que a Atividade 1 dá início ao aplicativo que está rodando como demonstração. Nesta Atividade é contido um botão com o rótulo de “Start Activity 2”, o qual é configurado para receber um evento e através do mesmo enviar uma mensagem, Intent, à plataforma para que a mesma identifique a Atividade 2 para execução, e assim por diante. Entretanto há um momento da execução da aplicação em que é pressionada a tecla Back do teclado digital do dispositivo. Esta tecla causa a destruição da ultima Atividade em execução, no caso a Atividade 3, chamando a Atividade 2 para continuar sua execução.

    Dessa forma, através desta demonstração é possível identificar duas coisas. Em primeiro lugar é visto que toda Atividade contém um ciclo de vida, aonde ele vai desde o início em sua identificação e criação por parte da Plataforma até a sua destruição, sendo que está será efetuada não somente com o pressionar do botão Back do dispositivo que estiver em questão, mas também mediante necessidade de memória que o mesmo dispositivo tiver.

    Apesar de que essa visualização tenha sido bem superficial, é necessária para compreender mecanismos básicos da Plataforma.

  3. Activities and Life-Cycle
  4. O importante a partir de então é entender melhor o funcionamento de uma Atividade. Como já vimos, as Atividades são blocos os quais podem ser visíveis e interagem com o usuário. Somente este bloco foi criado na Plataforma para isso, apesar de que a mesma poderá executar alguma operação sem que seja visualizada pelo usuário, entretanto tomando foco para efetuar seu trabalho ou executando-o em background com a utilização de Threads e Processos, todavia a abordagem mais correta para execução em background seria a utilização de Services, devida previsibilidade que a própria Plataforma Android dá para tal.

    Se verificarem a Figura 2 logo abaixo, visualizarão o ciclo de vida que uma Atividade contém. Toda Atividade é inicializada pela Plataforma através de um Intent. Neste momento se dá a identificação e criação de uma Activity. Após o componente ser identificado e “estartado”, ele passa por um processo de inicialização de estados, indicado pelo método onCreate() na figura. É neste feita toda a inicialização de componentes e estados. É também neste configurados os eventos em botões e as ações destes eventos. A partir deste momento é que a Atividade saberá com quais componentes ela deverá trabalhar e também é o senário recomendado para verificar os parâmetros necessários para a execução da mesma.

    Figura 2 – Ciclo de vida de uma Atividade. Fonte: http://developer.android.com/guide/topics/fundamentals/activities.html

    Já verificada a autenticidade da execução, ou seja, contém todas as premissas para que realmente seja executada, é chegado o momento em que a Atividade deve configurar as informações a serem apresentadas. É neste momento em que a Atividade, já tendo parâmetros verificados, “setta” os componentes visuais com a informação retida. Por exemplo, a Atividade A recebeu da Atividade B anterior a ela uma mensagem através de um Intent. Essa mensagem se constitui de um objeto da classe Cliente. Dentro deste objeto existem informações sobre código, nome e data de nascimento, as quais serão apresentadas na Atividade A.

    Logo após o método onCreate() há uma chamada a onStart(). Neste momento a Atividade já é visível ao usuário do dispositivo Android. Portanto é aqui que deverão ser “estartados” possíveis BroadcastReceivers os quais impactem os componentes gráficos a serem apresentados.

    Posteriormente a isso é chegado o momento da execução de uma atividade: onResume(). Este método é utilizado pela Atividade pela primeira vez que é criada e por toda vez que a mesma retoma o foco. É este método que representa o momento que a Atividade está executando em foreground, está em foco. A própria documentação da Plataforma indica que se utilize de pouco código dentro deste método, pois pode haver constante transição entre o estado de adormecido e “resumed” (retornou do stand by), podendo pesar a aplicação para a utilização do usuário final.

    Já falando sobre onPause(), este é o método chamado pela plataforma toda vez que o dispositivo entra em stand by, quando uma caixa de diálogo é apresentada na Atividade em execução ou quando outra Atividade está com foco. Após a chamada do mesmo a Atividade em questão perderá o foco. E quando é chegado o momento da Atividade que anteriormente estava em execução voltar para foreground, o método onResume() é novamente chamado, mantendo o mesmo raciocínio já elaborado no parágrafo anterior. É interessante ressaltar que em onPause() é recomendável salvar todos os estados que foram alterados desde a criação da Atividade, pois haverá momentos que a Plataforma necessitará de memória, fazendo com que a essa volte ao ponto inicial do ciclo de vida. Sendo assim, se forem muito importantes os estados alterados, há prejuízos durante a execução da aplicação. Há mecanismos elaborados na plataforma para tal finalidade, mais especificamente a classe Bundle. Mais adiante, em outros posts, essa será vista.

    Tratando agora do método onStop(), este é o método executado antes que uma Atividade perca total visibilidade na tela do dispositivo. É o caso em que outra Atividade foi chamada para se apresentar. É aqui que todo Broadcast Receiver que impacte no layout deverá ser parado juntamente à Atividade, pois toda e qualquer alteração não fará impacto.

    É chegado o final do ciclo de vida de uma Atividade e para esta finalidade foi modelado o método onDestroy(), o qual será utilizado para aliviar os recursos utilizados, liberando-os para outros Componentes.

    Com este último exemplo é dada a conclusão do ciclo de vida de uma Atividade, que também será utilizado como exemplo para os outros componentes, pois se assemelham muito neste critério. Qualquer diferença presente haverá comentários referentes à mesma. Mas só mais uma observação quanto a isso: todos os métodos são chamados pela própria plataforma, pois é ela quem controla a backstack das Atividades, tanto que estes métodos são chamados de backstack methods.

  5. Filters and Intents
  6. Agora iremos começar a comentar um pouco sobre alguns mecanismos das chamadas aos componentes.

    Os primeiros a serem comentados são os Intents. Como já dito antes, são mensagens as quais “estartam” as Atividades, Receptores de sinal Broadcast (Broadcast Receivers) e Services, não somente repassando as informações necessárias para a Plataforma inicializar estes componentes, como também retornam as prováveis mensagens de retorno que existam durante o processamento de algumas informações.

    Então o que são Filters (Filtros)? São dados sobre suas aplicações e os recursos da plataforma. Toda funcionalidade que possa ser acessada por aplicações externas pode ser relacionada a um filtro, o qual define a função de um componente. Para quê isso serve? Você se lembra de que toda aplicação tem máquina virtual própria, processo próprio, Usuário Linux próprio e que você não inicializa os seus blocos de construção manualmente, que todos são inicializados pela Plataforma? Pois então. Esta é a forma que a Google achou para facilitar a modularização e o reconhecimento das funcionalidades dentro dos dispositivos implementadores do Google Android. Tudo isso é definido dentro do Manifeste, o qual será mais bem detalhado em outro momento. Por enquanto só precisam saber que é um arquivo de configuração em que seus componentes são identificados e tornados públicos.

    3.1.Funcionamento com Activities

    Toda e qualquer Atividade que você quiser tornar pública para outras aplicações deverá se utilizar de filtros para definir as funcionalidades empregadas nela. E anteriormente a inicialização desta Atividade por parte do Android para que a mesma efetue a funcionalidade para a qual foi requisitada. O componente chamador deverá indicar através do Intent utilizado a funcionalidade requerida e os dados necessários para tal funcionalidade ou identificar no Intent o componente específico e os dados necessários.

    Sentiu que houve no parágrafo anterior algo diferente? A questão do “componente específico”. Boiou? Vou explicar. É o seguinte, os filtros realmente são utilizados para tornar pública a sua aplicação, mas o mecanismo é o seguinte: o Intent quando genérico, ou seja, quando indica uma ação genérica juntamente com a categoria, não identifica qual Classe (Atividade) fará o serviço, só é identificado a funcionalidade requisitada. Já o Intent específico indica o Componente (Activity) a qual fará a funcionalidade, caso esse componente não esteja presente a funcionalidade não é respondida. No caso do Intent genérico, se houver outro componente que faça a funcionalidade, a mesma é correspondida.

    Esse é o mecanismo utilizado por Services e Broadcast Receivers também, logo desfazendo necessária a explicação integral do mesmo. Quando for realmente preciso identificar as diferenças e explica-las, eu o farei.

    Concluímos o mecanismo da troca de mensagem até então. Quando os detalhes de implementação forem essenciais serão introduzidos em hora oportuna.

sexta-feira, 22 de abril de 2011

Andando com as próprias pernas

  1. Orientações
  2. Como já existem vários sítios sobre como instalar o Eclipse, como instalar Android sdk, Plugin ADT e a configuração do ADT no Eclipse, não irei me apegar a estes detalhes. Para facilitar a busca para o aprendizado irei divulgar alguns desses para quem quiser ir avançando sozinho em lições.

    Mas eu vou fazer algumas observações: a versão do Eclipse é a (Helios) Classic 3.6, Google Android SDK contém as ferramentas necessárias para desenvolver em Android (contém todas as versões de SDKs, é só utilizar o Manager o qual vem com o pacote e baixar pelo própria a versão que irá ser utilizada: 2.1 update 1; sabendo instalar plugins no Eclipse, você instalará facilmente o ADT.

    Poderão se adequar aos seguintes sítios:

    Amanhã já postarei mais material para prosseguir no aprendizado sobre a plataforma Android.

    Grato. Até Amanhã!


    OBS.:qualquer dúvida me perguntem.

sábado, 16 de abril de 2011

Contextualização de Implementação

1 Contextualização

Primeiramente todos devem saber, o básico do básico, que Android é uma plataforma móvel. É básico, mas já é um passo adiante. Depois, devem entender que ela é mais que uma plataforma móvel qualquer, é baseada em Kernel Linux 2.6.


O que é isso? Para os desentendidos:


  • Kernel é o núcleo sobre o qual um sistema operacional é produzido;
  • Este Kernel cuida do cerne de um sistema operacional;
  • Este cerne pode ser: gerência da memória, escalonamento de processos, gerencia de dispositivos.

Basicamente isso aí citado. É só para irem se situando. Depois dessa “baboseira”, devem entender que Android se utiliza deste Kernel para operações mais complicadas do que as que vamos mexer. Entretanto, são obrigados a conhecer que Android não é só isso, que ele contém uma máquina virtual “tal qual” a Java Virtual Machine (JVM) utilizada pela Sun, hoje parte da Oracle. Esta máquina tem um nome, Dalvik. Dalvik faz parte de uma das camadas superiores ao Kernel Linux.
Vocês irão necessitar dessas informações quando forem desenvolver, pois em alguns momentos a compreensão de como a plataforma, basicamente, funciona é fator primordial de um possível sucesso, ou derrota no caso contrário (de não compreender).

Font: http://developer.android.com/images/system-architecture.jpg

Levando em consideração que a informação foi absorvida, prosseguiremos.

Agora chega o momento integralmente importante. É nesse que todos os futuros desenvolvedores Android devem se apegar. Tudo e qualquer coisa que você futuramente criar irá rodar em Dalvik Virtual Machine (DVM, como de agora em diante vou utilizar). DVM é a base para qualquer projeto criado.

A plataforma é baseada em virtualização. Tal abordagem é assim tomada para manter a integridade de suas e de diversas outras aplicações. Tendo uma aplicação sua própria máquina virtual, contexto de memória, recursos e tarefas. Esta pode se corromper de tal forma que o programa pare, entretanto, a plataforma não.

Outro recurso para integridade utilizado em Android é a definição de usuários Linux, advento do Kernel utilizado. Estou citando isso, pois futuramente precisarei desta informação para explicar algumas situações e possíveis compartilhamentos de recursos de aplicações diferentes, mesmo estas rodando em máquinas virtuais e com um Memory Space (grossamente traduzido para “espaço de memória”) diferentes. Outra coisa importantíssima é: não tenha uma má impressão e comece a pensar que Android vai ser difícil porque você não entende nada de Linux. Relaxe, fique tranqüilo; não chega a tanto.

A parte mais legal e interessante: Android utiliza Java como sua linguagem de programação! Bom para quem sabe Java e bom para quem sempre quis um motivo para aprender Java.

Observações a serem feitas neste dado momento (em letras garrafais): NÃO É UTILIZADA A PLATAFORMA JAVA, E SIM A LINGUAGEM JAVA, A QUAL ATRIBUI A SINTAXE AO DESENVOLVIMENTO DE APLICAÇÕES. ENTÃO, NÃO VÁ VOCÊ PENSANDO QUE UTILIZARÁ A VERSÃO 7 OU 8 DO JAVA POIS TÊM RECURSOS LEGAIS E BEM ÚTEIS. VOCÊ IRÁ UTILIZAR A BIBLIOTECA DO PRÓPRIO ANDROID QUE VOCÊ DESEJAR UTILIZAR (atualmente 3.0v, ou também conhecida por Honeycomb).


2 Entendendo a Plataforma

Agora, que você já sabe que Android utiliza a sintaxe de Java, sabe que suas aplicações vão conter uma máquina virtual própria e que vão utilizar o Kernel Linux e concomitantemente irá utilizar usuário Linux, iremos dar um passo a diante em relação ao detalhamento da plataforma.

2.1 Blocos de construção primitivos

Entende-se por blocos de construção primitivos as estruturas de dados complexas nas quais Android se baseia para o desenvolvimento de suas aplicações. É bom ter esclarecido que “complexo” não é “difícil” e sim “completo”. Logo, poderão se utilizar da afirmação que esses blocos de construção são estruturas completas, dotadas de unidade e autonomia, tudo isso mantendo a própria integridade e consequentemente da aplicação.

Ainda entendendo nada? Utilizando palavrinhas do cotidiano: Esses blocos são classes que são interpretadas pela Dalvik para a execução das rotinas a serem criadas por vocês em seus aplicativos e para a interação com o usuário final e a plataforma.

Falemos um pouco sobre eles


2.1.1 Activities (Atividades)

Atividades são os blocos mais importantes desta plataforma, pois são a única forma que o seu aplicativo tem para interagir com o usuário. São as Atividades, geralmente, a darem início na execução do seu programa. Sem elas seu sistema não conterá parte visível. Entretanto atividades podem ser utilizadas para a execução em ‘background’ de alguma informação que não necessite do aval do usuário, portanto, não contendo parte visível.

Todo e qualquer componente visível será embutido em atividades. Listas, Tabelas, Combos, Labels, entre outros componentes conhecidos serão adequados ao espaço em tela que uma atividade contém.

Toda vez que estiver visualizando uma tela em um aparelho Google Android, ali estará presente uma *única Atividade. Essa poderá chamar outra para efetuar transição de tela passando ou não informações adicionais para a mesma, requisitar informações de outra Atividade, requisitar informações dos outros blocos de construção (que serão apresentados). Os mecanismos para tais funcionalidades serão apresentados em momento oportuno.

Eu coloquei a palavra “única” no parágrafo anterior com um asterisco, pois neste momento é importante entender que a plataforma tem evoluído bastante e a versão que eu mexo é a 2.1 update 1. Na versão 3.0 (Honeycomb), é possível conter uma “atividade fragmentada”, a qual utiliza-se de um novo componente incluído nessa versão. Esses Fragmentos têm seu próprio ciclo de vida e funcionam tal qual uma Atividade, quando comparadas suas funcionalidades de interação com o usuário.

Como eu nunca utilizei este nível de recurso, não sei dizer muito além do que o sítio da plataforma diz (Sítio Android SDK. Tópicos sobre Fragments). Como não há forma de aprender Fragment sem aprender Activity, não vai ser uma preocupação presente para mim.


2.1.2 Services (Serviços)

Serviços são componentes para a execução em ‘background’. Geralmente um serviço é iniciado para uma longa execução. Essa execução poderá ser por tempo indeterminado ou previsível.

Outro uso do Serviço é executar operações específicas as quais outros processos não o fazem e requisitam a um serviço a execução. Um exemplo: você instalou o Skype no seu celular, só que lembrou que tinha que enviar uma mensagem de texto para seu(a) chefe avisando que o relatório de terça feira foi entregue. No mesmo momento em que você está digitando sua mensagem, sua namorada responde o que você havia deixado de pergunta na sessão do Skype. Como você acha que a mensagem que ela mandou foi recebida no seu celular? Por um serviço.

Um serviço não utiliza componente visível. A execução do mesmo será sempre em background.


2.1.3 Content Provider (Provedor de Conteúdo)

Os provedores de conteúdo são autoexplicativos. Os mesmos são utilizados para acesso remoto de dados de outras aplicações. Este recurso é aplicado à plataforma, pois facilita a modularização do seu aplicativo.

Com o Content Provider você consegue fazer sua persistência de dados com o menor nível de acoplamento possível. Será possível entender os mecanismos mais tarde, em outros posts, entretanto é importante entender que este componente é uma classe utilizada para interface com o projeto de persistência de dados. Esta persistência pode ser feita em um banco de dados SQLite ou de qualquer outra forma que você possivelmente criará ou reutilizar.

Para quem não está acostumado com os conceitos de coesão e acoplamento: acoplamento é ao nível da solução uma dependência gerada através do nível do conhecimento que um componente contém do outro. Resumidamente, duas coisas diferentes, interagindo para um fim comum, porém uma não faz seu serviço sem que a outra exista e qualquer alteração em uma acarreta em alterações na outra.

Já o nível de Coesão é dado pela divisão de responsabilidades. Um código terá alto nível de coesão, caso este resolva um único problema específico. Se um método é criado para fazer uma soma, que ele seja responsável só e por toda a soma. Quanto melhor a responsabilidade for dividida, maior será a coesão.

O conceito de Coesão é bastante utilizado quando vamos falar de reaproveitamento de componentes, pois um componente é bastante coeso quando esse se adéqua a várias situações diferentes. Por indução, um componente atrelado a uma só situação - totalmente acoplado a uma única situação – tem baixo nível de coesão.


2.1.4 Broadcast Receiver (Receptor de broadcast)

É ele o responsável por receber alguns sinais para todo o sistema. Vários sinais de broadcast são enviados pela plataforma para indicar ao usuário do aparelho algumas situações: bateria fraca, a tela desligou, etc.

Mas esses sinais também podem ser enviados pelos seus programas. Você pode indicar que o download de uma imagem terminou, o arquivo foi enviado, mensagem foi recebida, etc. Já os outros programas, se quiserem, capturarão os mesmo mediante Broadcast Receivers.

Não há muito que se falar sobre esse componente. Ele servirá para tudo isso ai que vocês estão vendo.


2.2 Ativação dos componentes (Instanciação)

Este é o momento chave para compreender o mecanismo da plataforma Android. Por que estou dizendo isto? Pois a plataforma Android trabalha de uma forma diferenciada do costume geral das aplicações. Ela trabalha de forma a se assemelhar aos Applets em Java, contendo seus próprios ciclos de vida e pontos de execução dos componentes.

Não é você o responsável a “estartar” os blocos primitivos de construção da plataforma. É a própria plataforma que se encarrega desta obrigação, identificando sempre o componente correto para cada situação.

Este mecanismo se dá através de Intents (intenções – intenções de uso) para Atividades, Serviços e Broadcast Receivers. Toda vez que você pretender utilizar um destes componentes, você indica isso à plataforma por meio de um objeto Intent. Este objeto leva a mensagem até a plataforma, que interpreta e decide qual é o componente certo para a posterior execução. Já a mensagem pode ser enviada através dos métodos criados e implementados (pela própria plataforma; nativos) em cada componente para esta finalidade.

Já os mecanismos, como viram até aqui desde o início do blog, serão apresentados em hora oportuna. Há detalhes de implementação que só valem a pena serem comentados no momento da implementação. Eu escolho esta abordagem, pois é melhor que eu rebusque uma informação toda vez que necessário do que obrigarem vocês a buscá-la para relembrá-la.

Voltando ao raciocínio anterior... A mensagem citada anteriormente é assíncrona, pois a conexão de envio da mensagem não é a mesmo da recepção da resposta. Quando uma atividade “provoca” outra através de um Intent, ela “adormece” esperando ser provocada novamente. Isso se dá ou pelo envio da resposta esperada pela Atividade “provocadora” por parte da “provocada”, ou pela finalização da “provocada”. É muito abstrato por enquanto, mas entender a lógica do funcionamento é melhor que entender o mecanismo, pois o mecanismo se tornará intuitivo no momento da implementação.

Diferenciando-se um pouco desta abordagem vem os Provedores de Conteúdo. Esses já não se utilizam de Intents para serem provocados. A plataforma resolve isso de forma diferente. O componente responsável por provocar um Content Provider é o Content Resolver. Este recebe o requerimento ao Content Provider específico através de um mecanismo chamado URI (também vai ser explicado em posts posteriores). Esta URI é interpretada e após a interpretação é identificado o provedor necessário. Nesse momento a plataforma se encarrega de verificar se há alguma instancia do provedor ou se será necessário criar outra, como ocorre com os demais componentes.

Desta forma, acessando a persistência de dados utilizada, podendo ser SQLite ou qualquer outra forma que você venha a criar ou reutilizar.

Assim, finalizando a parte básica sobre os componentes primitivos desta plataforma.

domingo, 10 de abril de 2011

Funcionamento do Blog

Tentarei me adequar a uma postagem semanal, geralmente, no final de semana por ter mais tempo. Poderei postar mais de um material dependentemente a quantidade que eu tiver para postar.

Primeiramente passarei as linhas gerais da plataforma: blocos de construção primários da plataforma Android, troca de mensagem, execução de aplicações, utilização do plugin ADT para Eclipse, etc. Com o tempo vou esclarecendo melhor esses detalhes.

Chegamos na parte em que os usuários do NetBean não serão satisfeito. Por decisão própria, e melhor adequação do ambiente para finalidade de desenvolvimento de aplicações Android, estarei utilizando o Eclipse Helios com o plugin ADT (Android Development Tool).

Sintam-se livres para críticas, observações, dicas e adequação do meu material. Poderão apontar erros didáticos, erros em exemplos práticos e possíveis equívocos que eu possa cometer.

Vamos levando o blog do jeito que podemos. Tomara que consigamos evoluir à medida do tempo e conquistemos vários apreciadores da plataforma.

Eu explicarei melhor como baixar a IDE Eclipse e como instalar o ADT no mesmo, em momento oportuno. Tentarei ser o mais demonstrativo o possível.

Esclarecerei eventualidades conforme forem aparecendo. Grato!

Android: um novo estilo de vida.


Primeiramente queria dizer o propósito para que vim por meio deste para divulgar-lhes sobre a plataforma Google Android:

  1. Não achei muito confortável a presente documentação do Android.
  2. A plataforma é relativamente nova, entretanto é muito poderosa e capaz.
  3. O meu contato com a plataforma é muito recente, não sei tudo sobre ela, porém busco a cada dia mais. Logo, o blog não só é a minha forma de passar aquilo que vou aprendendo e descobrindo, como aprender com possíveis postagens e outros blogs ou materiais influenciados pelos mesmos motivos que os meus.

Basicamente é isso. Como podem verificar eu sou novo no Android. Há pessoas no mercado mais experientes do que eu, porém sei a importância de se conquistar uma boa `network`, sendo esta a minha primeira atitude referente a isso.

Espero que gostem das postagens, que seja este blog o primeiro local a ser vasculhado em toda busca referente a aprendizagem sobre essa plataforma.

E que Deus nos abençoe!

Amém!