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.

Nenhum comentário:

Postar um comentário