- Backstack
- Activities and Life-Cycle
- Filters and Intents
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.
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.
Figura 1 – Android Backstack. Font: http://developer.android.com/guide/topics/fundamentals/tasks-and-back-stack.html.
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.
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.
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.
