Diferença entre onStart () e onResume ()

Não consigo entender o significado do onStart()estado de transição. O onResume()método é sempre chamado depois onStart(). Por que não pode ser onResume()chamado depois onRestart()e onCreate()métodos excluídos onStart()? Qual é seu propósito?

Por que não podemos viver sem onStart(). Ainda o considero redundante (provavelmente porque não entendo completamente seu significado).

Por que não pode ser invocado o onResume () após os métodos onRestart () e onCreate (), excluindo apenas onStart ()? Qual é seu propósito?

OK, como minha primeira resposta foi bem longa, não vou estendê-la ainda mais, então vamos tentar isso ...

public DriveToWorkActivity extends Activity
    implements onReachedGroceryStoreListener {
}

public GroceryStoreActivity extends Activity {}

ATENÇÃO: Eu deliberadamente deixei de lado as chamadas para coisas como super.onCreate(...)etc. Isso é pseudo-código, então me dê uma licença artística aqui. ;)

Os métodos para DriveToWorkActivityseguir ...

protected void onCreate(...) {
    openGarageDoor();
    unlockCarAndGetIn();
    closeCarDoorAndPutOnSeatBelt();
    putKeyInIgnition();
}

protected void onStart() {
    startEngine();
    changeRadioStation();
    switchOnLightsIfNeeded();
    switchOnWipersIfNeeded();
}

protected void onResume() {
    applyFootbrake();
    releaseHandbrake();
    putCarInGear();
    drive();
}

protected void onPause() {
    putCarInNeutral();
    applyHandbrake();
}

protected void onStop() {
    switchEveryThingOff();
    turnOffEngine();
    removeSeatBeltAndGetOutOfCar();
    lockCar();
}

protected void onDestroy() {
    enterOfficeBuilding();
}

protected void onReachedGroceryStore(...) {
    Intent i = new Intent(ACTION_GET_GROCERIES, ...,  this, GroceryStoreActivity.class);
}

protected void onRestart() {
    unlockCarAndGetIn();
    closeDoorAndPutOnSeatBelt();
    putKeyInIgnition();
}

OK, então é outra longa (desculpe pessoal). Mas aqui está a minha explicação ...

onResume()é quando eu começo a dirigir e onPause()é quando eu paro temporariamente. Então eu dirijo e chego a um sinal vermelho, então paro ... a luz fica verde e eu recomeço. Outra luz vermelha e eu paro, depois verde, para continuar. O onPause() -> onResume() -> onPause() -> onResume()ciclo é apertado e ocorre muitas vezes ao longo da minha jornada.

O loop de parar novamente através de um reinício (preparando-se para continuar minha jornada) e começar de novo é talvez menos comum. Em um caso, localizo a mercearia e ela GroceryStoreActivityé iniciada (forçando- DriveToWorkActivitya a ponto de onStop()). Quando volto da loja, passo onRestart()e retomo onStart()minha jornada.

Eu poderia colocar o código que está onStart()dentro dos dois onCreate()e sem onRestart()me preocupar em substituir onStart(), mas quanto mais isso precisa ser feito entre onCreate() -> onResume()e onRestart() -> onResume(), mais estou duplicando as coisas.

Então, para cotar mais uma vez ...

Por que não pode ser invocado o onResume () após os métodos onRestart () e onCreate (), excluindo apenas onStart ()?

Se você não substituir onStart(), é efetivamente o que acontece. Embora o onStart()método de Activityseja chamado implicitamente, o efeito no seu código é efetivamente onCreate() -> onResume()ou onRestart() -> onResume().

Resposta curta:

Não podemos viver sem o onStart, porque esse é o estado em que a atividade se torna "visível" para o usuário, mas o usuário não pode "interagir" com ela, mas pode ser porque se sobrepôs a outra pequena caixa de diálogo. Essa capacidade de interagir com o usuário é a que diferencia onStart e onResume. Pense nisso como uma pessoa atrás de uma porta de vidro. Você pode ver a pessoa, mas não pode interagir (conversar / ouvir / apertar as mãos) com ela. O OnResume é como o abridor de portas após o qual você pode iniciar a interação.

Além disso, onRestart () é o menos compreendido. Podemos fazer a pergunta sobre por que não ir diretamente para onStart () ou onResume () depois de onStop () em vez de onRestart (). Torna-se mais fácil entender se notarmos que onRestart () é parcialmente equivalente a onCreate () se a parte de criação for omitida. Basicamente, ambos os estados levam a onStart () (ou seja, a atividade se torna visível). Portanto, ambos os estados precisam "preparar" o material a ser exibido. O OnCreate tem a responsabilidade adicional de "criar" o material a ser exibido

Portanto, suas estruturas de código podem se encaixar em algo como:

onCreate()
{
     createNecessaryObjects();

     prepareObjectsForDisplay();
}


onRestart()
{
     prepareObjectsForDisplay();

}

Toda a confusão é causada porque o Google escolheu nomes não intuitivos em vez de algo da seguinte maneira:

onCreateAndPrepareToDisplay()   [instead of onCreate() ]
onPrepareToDisplay()            [instead of onRestart() ]
onVisible()                     [instead of onStart() ]
onBeginInteraction()            [instead of onResume() ]
onPauseInteraction()            [instead of onPause() ]
onInvisible()                   [instead of onStop]
onDestroy()                     [no change] 

O diagrama de atividades pode ser interpretado como:

onStart()chamado quando a atividade está se tornando visível para o usuário. onResume()chamado quando a atividade começará a interagir com o usuário. Você pode querer fazer coisas diferentes nesses casos.

Veja este link para referência.

onResume() é chamado:

1. depois de onStart()
2. quando se Activitytrata de primeiro plano.

Em http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle :

O livro "Olá, Android, Apresentando a Plataforma de Desenvolvimento Móvel do Google" fornece uma boa explicação do ciclo de vida dos aplicativos Android. Felizmente, eles têm o capítulo específico online como um trecho. Veja o gráfico na página 39 em http://media.pragprog.com/titles/eband3/concepts.pdf

A propósito, este livro é altamente recomendável para iniciantes no Android!

Um exemplo particularmente enérgico é quando você decide mostrar um Diálogo gerenciado de uma Atividade usando showDialog(). Se o usuário girar a tela enquanto a caixa de diálogo ainda estiver aberta (chamamos isso de "alteração de configuração"), a Atividade principal passará por todas as chamadas de ciclo de vida até onDestroy()que sejam concluídas , será recriada e retornará pelos ciclos de vida. O que você não pode esperar, no entanto, é que onCreateDialog()e onPrepareDialog()(os métodos chamados quando você o faz showDialog()e agora novamente automaticamente para recriar a caixa de diálogo - automaticamente por ser uma caixa de diálogo gerenciada) são chamados entre onStart() e onResume(). A dica aqui é que a caixa de diálogo não cobre a tela inteira e, portanto, deixa visível parte da atividade principal. É um detalhe, mas importa!

onStart()

1. Chamado após onCreate (Bundle) ou após onRestart () seguido por onResume () .
2. você pode registrar um BroadcastReceiver onStart()para monitorar alterações que afetam sua interface do usuário. É necessário cancelar o registro em onStop ()
3. As classes derivadas devem chamar a implementação desse método pela superclasse. Caso contrário, uma exceção será lançada.

onResume()

1. Chamado após onRestoreInstanceState (Bundle), onRestart () ou onPause ()
2. Comece animações, abra dispositivos de acesso exclusivo (como a câmera)

onStart() normalmente despacha o trabalho para um encadeamento em segundo plano, cujos valores de retorno são:

• START_STICKY para reiniciar automaticamente se for morto, para mantê-lo ativo.

• START_REDELIVER_INTENT para reinicialização automática e tente novamente se o serviço foi interrompido antes de stopSelf ().

onResume()é chamado pelo sistema operacional depois que o dispositivo entra em suspensão ou após um alerta ou outra atividade filho em tela parcial deixar visível uma parte da janela anterior, portanto é necessário um método para reinicializar os campos (em uma estrutura de tentativa com várias exceções) ) Tal situação não faz com onStop()que seja invocada quando a criança se fecha.

onResume()é chamado sem onStart()quando a atividade é retomada em segundo plano

Para obter mais detalhes, você pode visitar Android_activity_lifecycle_gotcha e ciclo de vida da atividade

Esperemos que uma explicação simples: -

onStart () -> chamado quando a atividade se torna visível, mas pode não estar em primeiro plano (por exemplo, um AlertFragment está no topo ou qualquer outro caso de uso possível).

onResume () -> chamado quando a atividade está em primeiro plano ou o usuário pode interagir com a atividade.

onStart()significa que Activityentrou no estado visível e o layout é criado, mas não pode interagir com esse layout de atividade.

Resume() significa que agora você pode interagir com o layout da atividade.

Observe que há coisas que acontecem entre as chamadas para onStart () e onResume (). Ou seja, onNewIntent (), que eu descobri dolorosamente.

Se você estiver usando o sinalizador SINGLE_TOP e enviar alguns dados para sua atividade, usando extras de intenção, poderá acessá-los apenas em onNewIntent (), que é chamado após onStart () e antes de onResume (). Geralmente, você pega os novos dados (talvez apenas modificados) dos extras e os define para alguns membros da classe ou usa setIntent () para definir a nova intenção como a atividade original e processar os dados em onResume ().

Referência a http://developer.android.com/training/basics/activity-lifecycle/starting.html

onResume()Chamado imediatamente antes da atividade começar a interagir com o usuário. Nesse ponto, a atividade está no topo da pilha de atividades, com a entrada do usuário. Sempre seguido por onPause().

onPause()Chamado quando o sistema está prestes a começar a retomar outra atividade. Esse método geralmente é usado para confirmar alterações não salvas em dados persistentes, interromper animações e outras coisas que possam estar consumindo CPU e assim por diante. Ele deve fazer o que fizer muito rapidamente, porque a próxima atividade não será retomada até que retorne. Seguido por onResume()se a atividade retornar para a frente ou por onStop()se tornar invisível para o usuário.

Não tenho certeza se isso conta como resposta - mas aqui está o vídeo do YouTube do curso do Google (Desenvolvendo aplicativos Android com Kotlin) que explica a diferença.

• On Start é chamado quando a atividade se torna visível
• Em Pausa é chamado quando a atividade perde o foco (como uma caixa de diálogo é exibida)
• On Resume é chamado quando a atividade ganha foco (como quando um diálogo desaparece)