Processos e ciclo de vida do aplicativo

Na maioria dos casos, cada aplicativo para Android é executado no próprio processo do Linux. Esse processo é criado para o aplicativo quando parte do código precisa ser executada e permanece em execução até que o sistema precise recuperar a memória para uso por outros aplicativos e ela não seja mais necessária.

Um recurso incomum e fundamental do Android é que o ciclo de vida do processo de um aplicativo não é controlado diretamente pelo próprio aplicativo. Em vez disso, ele é determinado pelo sistema por uma combinação das partes do aplicativo que o sistema sabe que estão em execução, da importância dessas coisas para o usuário e da quantidade de memória geral disponível no sistema.

É importante que os desenvolvedores de aplicativos entendam como diferentes componentes de aplicativos (em particular Activity, Service e BroadcastReceiver) afetam o ciclo de vida do processo do aplicativo. Se esses componentes não forem usados corretamente, o sistema poderá encerrar o processo do aplicativo enquanto ele estiver realizando um trabalho importante.

Um exemplo comum de bug no ciclo de vida do processo é um BroadcastReceiver que inicia uma linha de execução quando recebe um Intent no método BroadcastReceiver.onReceive() e, em seguida, retorna da função. Depois que ele retorna, o sistema considera que o BroadcastReceiver não está mais ativo e que o processo de hospedagem não é mais necessário, a menos que outros componentes de aplicativo estejam ativos nele.

Portanto, o sistema pode encerrar o processo a qualquer momento para recuperar memória e, ao fazer isso, encerra a linha de execução gerada em execução no processo. A solução para esse problema geralmente é programar um JobService do BroadcastReceiver para que o sistema saiba que há um trabalho ativo ocorrendo no processo.

Para determinar quais processos encerrar quando há pouca memória, o Android coloca cada processo em uma hierarquia de importância com base nos componentes em execução e no estado deles. Em ordem de importância, esses tipos de processo são:

  1. Um processo em primeiro plano é necessário para o que o usuário está fazendo no momento. Vários componentes de aplicativos podem fazer com que o processo que os contém seja considerado em primeiro plano de maneiras diferentes. Um processo é considerado em primeiro plano se alguma das condições abaixo for atendida:

    Há apenas alguns processos desse tipo no sistema, e eles só são encerrados como último recurso se a memória estiver tão baixa que nem mesmo esses processos possam continuar em execução. Geralmente, se isso acontecer, o dispositivo atingiu um estado de paginação de memória. Portanto, essa ação é necessária para manter a interface do usuário responsiva.

  2. Um processo visível está realizando um trabalho que o usuário conhece. Portanto, encerrá-lo tem um impacto negativo perceptível na experiência do usuário. Um processo é considerado visível nas seguintes condições:
    • Ele está executando uma Activity que está visível para o usuário na tela, mas não em primeiro plano (o método onPause() foi chamado). Isso pode ocorrer, por exemplo, se a Activity em primeiro plano for mostrada como uma caixa de diálogo que permite que a Activity anterior seja vista atrás dela.
    • Ele tem um Service que está sendo executado como um serviço em primeiro plano, por meio de Service.startForeground() (que pede ao sistema para tratar o serviço como algo que o usuário conhece ou, essencialmente, como se estivesse visível).
    • Ele hospeda um serviço que o sistema está usando para um recurso específico que o usuário conhece, como um plano de fundo interativo ou um serviço de método de entrada.

    O número desses processos em execução no sistema é menos limitado do que os processos em primeiro plano, mas ainda é relativamente controlado. Esses processos são considerados extremamente importantes e não são encerrados, a menos que isso seja necessário para manter todos os processos em primeiro plano em execução.

  3. Um processo de serviço é aquele que contém um Service que foi iniciado com o método startService(). Embora esses processos não sejam diretamente visíveis para o usuário, eles geralmente estão fazendo coisas importantes para o usuário, como upload ou download de dados de rede em segundo plano. Por isso, o sistema sempre mantém esses processos em execução, a menos que não haja memória suficiente para reter todos os processos em primeiro plano e visíveis.

    Os serviços que estão em execução há muito tempo (por exemplo, 30 minutos ou mais) podem ser rebaixados em importância para que o processo seja descartado para a lista em cache.

    Os processos que precisam ser executados por um longo período podem ser criados com setForeground. Se for um processo periódico que exige um tempo de execução estrito, ele poderá ser programado pelo AlarmManager. Para mais informações, consulte Suporte para workers de longa duração. Isso ajuda a evitar situações em que serviços de longa duração que usam recursos excessivos, por exemplo, vazando memória, impedem que o sistema ofereça uma boa experiência do usuário.

  4. Um processo em cache é aquele que não é necessário no momento. Portanto, o sistema pode encerrá-lo conforme necessário quando recursos como memória forem necessários em outro lugar. Em um sistema que se comporta normalmente, esses são os únicos processos envolvidos no gerenciamento de recursos.

    Um sistema que funciona bem tem vários processos em cache sempre disponíveis para uma alternância eficiente entre aplicativos e encerra regularmente os apps em cache conforme necessário. Somente em situações muito críticas o sistema chega a um ponto em que todos os processos em cache são encerrados e ele precisa começar a encerrar os processos de serviço.

    Como os processos em cache podem ser encerrados pelo sistema a qualquer momento, os apps precisam interromper todo o trabalho enquanto estiverem nesse estado. Se o app precisar realizar um trabalho essencial para o usuário, ele precisará usar uma das APIs acima para executar o trabalho em um estado de processo ativo.

    Os processos em cache geralmente contêm uma ou mais instâncias de Activity que não estão visíveis para o usuário no momento. O método onStop() delas foi chamado e retornou. Se o ciclo de vida de Activity for implementado corretamente quando o sistema encerrar esses processos, a experiência do usuário não será afetada ao retornar ao app. Ele pode restaurar o estado salvo anteriormente quando a atividade associada for recriada em um novo processo. Não há garantia de que onDestroy() será chamado se um processo for encerrado pelo sistema. Para mais detalhes, consulte Activity.

    A partir do Android 13, um processo de app pode receber tempo de execução limitado ou nenhum tempo de execução até entrar em um dos estados de ciclo de vida da atividade ativos acima.

    Os processos em cache são mantidos em uma lista. A política de ordenação exata dessa lista é um detalhe de implementação da plataforma. Em geral, ele tenta manter processos mais úteis, como aqueles que hospedam o aplicativo inicial do usuário ou a última atividade que o usuário viu, antes de outros tipos de processos. Outras políticas para encerrar processos também podem ser aplicadas, como definir limites rígidos para o número de processos permitidos ou limitar o tempo que um processo pode permanecer continuamente em cache.

Ao decidir como classificar um processo, o sistema baseia a decisão no nível mais importante encontrado entre todos os componentes ativos no processo. Consulte a documentação de Activity, Service e BroadcastReceiver para mais detalhes sobre como cada um desses componentes contribui para o ciclo de vida geral de um processo e do aplicativo.

A prioridade de um processo também pode ser aumentada com base em outras dependências que um processo tem em relação a ele. Por exemplo, se o processo A estiver vinculado a um Service com a flag Context.BIND_AUTO_CREATE ou estiver usando um ContentProvider no processo B, a classificação do processo B será sempre pelo menos tão importante quanto a do processo A.