Lifecycle Android

Fala pessoal, beleza?!

Hoje eu gostaria de compartilhar aqui os resultados de muito estudo que tive recentemente, com certeza os desenvolvedores Android já passaram ou ainda estão passando por isso. Afinal é um fundamentals do desenvolvimento Android. 

A medida que você navega em um app, você está transitando pelo que o Android chama de activitys, e essas atividades sofrem alterações de estado constantemente. As activitys são formadas em modo de pilha, uma acima da outra. Então em algum momento sua activity poderá ficar em primeiro, segundo, terceiro...plano! 

Sabe aquela ligação que você recebe enquanto navega em um app e quando você retorna, tchanam! Está no ponto onde você parou, suas informações foram salvas?!

Já deve ter percebido também que por segurança, apps de banco e de cartão de crédito, pedem que você logue novamente após alguns minutos de inatividade ou mudança de atividade. 

Isso acontece pois o Android definiu o ciclo de vida da activity! São métodos pelos quais sua activity vai passar durante sua duração, onde você pode controlar essas mudanças e alterar a ação que ela fará em cada um desses métodos.

Ao criar uma activity o Android Studio implementa o método onCreate().

onCreate() - Sua activity é criada. Executa a lógica básica de inicialização. É aqui que inflamos nosso layout, por exemplo.

Isto é, ao criar sua activity esse processo guarda o estado dos objetos instanciados e inicializados aqui, até que essa activity passe pelo onDestroy() - já iremos falar sobre esse cara -. 

Alguns métodos desse ciclo não necessariamente serão sobrecarregados por você no código, mas isso não significa que sua activity não passará por eles. Entender quais atividades passarão por cada método e saber implementá-los é essencial. Afinal, se você não sobrecarregá-los no código eles terão uma implementação padrão herdada da classe Activity.

onStart() - Criada sua lógica inicial, o nosso amiguinho aqui que vai tornar tudo visível ao usuário! Por exemplo, é nesse método que o aplicativo inicializa o código que mantém a interface do usuário, aquela que você interage. Ao retornar a sua atividade em algum momento, é a partir desse método que sua activity vai passar, e não mais pelo onCreate().

onResume() - É por causa desse cara aqui que você consegue interagir com a aplicação! É ele que aguenta as pontas até o foco do seu app mudar, por exemplo, até você receber uma ligação.

onPause() - Você atendeu a ligação, por exemplo, o callback chamado foi o onPause(). Ele te ajuda bastante na hora de economizar a bateria, pois sua activity não vai salvar nenhum dado ou executar transações de banco de dados, afinal esse tipo de trabalho pode não ser concluído antes da finalização do método. Use o método onPause() para pausar ou ajustar operações que não devem continuar (ou que precisem continuar com moderação) enquanto a Activity estiver no modo "Pausado" e aquelas que você espera retomar em breve. Afinal sua atividade sofreu uma mudança, ela não está mais em primeiro plano, mas que você sabe ser por pouco tempo. Ao retornar o callback chamado será o onResume(). 

onStop() - Se a atividade ficar completamente invisível, o sistema chamará esse callback. O aplicativo poderá pausar animações ou alternar de atualizações de local mais específicas para as menos detalhadas. O uso de onStop() em vez de onPause() garante que o trabalho relacionado à interface do usuário continue. Esse método te ajuda a reciclar as atividades do seu app sem precisar passar pelo método onResume() quando o usuário retornar à activity. Por exemplo: deseja salvar informações inseridas em um EditText e se não encontrar outro momento oportuno, poderá realizar transações de banco de dados, por exemplo. 

A partir do estado onStop(), a atividade volta a interagir com o usuário ou pára de operar e é encerrada. Se a atividade voltar, o sistema invocará onRestart(). Caso a Activity deixe de operar, o sistema chamará onDestroy().

onDestroy() - Esse método é chamado antes de a atividade ser destruída. Se em algum método anterior foi chamado um método de finalização - finish(), se o usuário descartou totalmente a aplicação ou o sistema está destruindo temporariamente a atividade devido a uma mudança na configuração (como a rotação do dispositivo ou o modo de várias janelas).

O sistema elimina processos quando precisa liberar RAM e a probabilidade do sistema eliminar um determinado processo depende do estado do processo no momento. O estado do processo, por sua vez, depende do estado da atividade em execução no processo.

Porém, você pode guardar o estado de sua aplicação para que o usuário consiga navegar tranquilamente, implementando o método savedInstanceState(). O sistema destrói a atividade por padrão quando ocorre alguma mudança de configuração. Isso exclui qualquer estado da interface do usuário já armazenado na instância da atividade, criada como parâmetro no onCreate(). Porém a medida que a atividade começar a parar, o sistema chama o método onSaveInstanceState() para que ela possa salvar a informação do estado em um pacote de estado da instância. Então, você deverá implementar nesse método, todas as alterações necessárias para conseguir acessar o estado anterior novamente após o ciclo onDestroy().

Gostaria de ver como isso funciona? Abra uma nova aplicação no Android Studio, implemente esses métodos, como na imagem, adicione logs a eles e veja no seu Logcat a mágica acontecer! (OBS: O logcat pode ser confuso, então pesquise por activity para vizualisar melhor!) Não se esqueça de usar a rotação do emulador ou celular e criar mais de uma activity para ver todos esses métodos em ação.

Nesse artigo claramente não trato de todos os métodos da activity lifecycle, posso falar mais sobre outros métodos em outra oportunidade...o que acham?