Qual é a diferença entre onPause () e onStop () das atividades do Android?

No documento do Android, aqui http://developer.android.com/reference/android/app/Activity.html , dizia 'Atividade entra em primeiro plano' será chamada onPause()e 'Atividade não está mais visível' será chamada onStop().

'Atividade entra em primeiro plano' não é o mesmo que 'Atividade não está mais visível'? Você pode me dizer qual é a diferença entre eles?

Não, se alguma atividade entrar em primeiro plano, isso não significa necessariamente que a outra atividade seja completamente invisível. Considere o seguinte caso:

Aqui vemos as duas atividades ao mesmo tempo. A primeira atividade com os campos é obscurecida por outra atividade e o usuário não pode mais interagir com ela. No entanto, ainda é visível com todas as consequências resultantes.

Isso deixa uma dúvida sobre qual atividade é considerada totalmente opaca e cobre toda a tela e qual não é. Esta decisão é baseada na janela que contém a atividade. Se a janela tiver um sinalizador windowIsFloatingou windowIsTranslucent, considera-se que a atividade não torna invisível o material subjacente; caso contrário, ele faz e fará com onStop()que seja chamado. O código relevante pode ser encontrado em com.android.server.am.ActivityRecord:

fullscreen = ent != null && !ent.array.getBoolean(
        com.android.internal.R.styleable.Window_windowIsFloating, false)
        && !ent.array.getBoolean(
        com.android.internal.R.styleable.Window_windowIsTranslucent, false);

Se você ainda conseguir ver parte dela (o Activityprimeiro plano não ocupa a tela inteira ou é um pouco transparente), onPause()será chamado. Se você não conseguir ver nenhuma parte, onStop()será chamado.

Uma caixa de diálogo **, por exemplo, pode não cobrir todo o anterior Activity, e esse seria um momento para onPause()ser chamado.

** Não estou me referindo a um Diálogo Android aqui, mas a uma idéia conceitual de algo que aparece e oculta apenas parte da tela do usuário. Esta nota foi adicionada para esclarecer com base em um comentário de @GMsoF abaixo

Estar em primeiro plano significa que a atividade tem foco de entrada. Por exemplo, uma atividade pode ser visível, mas parcialmente obscurecida por uma caixa de diálogo focada. Nesse caso, onPause()será chamado, mas não onStop(). Quando a caixa de diálogo desaparecer, o onResume()método da atividade será chamado (mas não onStart()).

Na prática , deve-se considerar a diferença entre “onPause ()” e “onPause () + onStop ()”.

Sempre que alguma nova atividade ocorre e ocupa algum espaço parcial da tela. Portanto, sua atividade em execução anterior ainda é visível até certo ponto. Nesse caso, a atividade em execução anterior não é enviada para Back Stack. Portanto, aqui apenas o método onPause () é chamado .

Por outro lado, se alguma nova atividade ocorrer e ocupar a tela inteira para que sua atividade em execução anterior desapareça. Nesse caso, sua atividade em execução anteriormente é movida para Back Stack. Aqui, onPause () + onStop () são chamados.

Para Resumos

onPause () - a tela é parcialmente coberta por outra nova atividade. A atividade não é movida para a pilha traseira.

onPause () + onStop () - a tela é totalmente coberta por outra nova atividade. A atividade é movida para a pilha traseira.

Saiba mais sobre- Back Stack .

Em palavras concisas:

onStop()do método de ciclo de vida da atividade anterior é chamado quando outra atividade é mostrada. Quando você tem o Diálogo no topo da atividade, ele onPause()é chamado.

Nota : Atividades são os componentes que preenchem sua tela inteira.

Nota : Os diálogos não são Atividade, pois não preenchem completamente a tela.

Enfrentei muitos problemas com os métodos onPause e onStop e, portanto, limparei três cenários que encontrei:
1. Quando você clica no botão do aplicativo recente, nenhum método de ciclo de vida é chamado, mas o onWindowFocusChanged (boolean hasFocus) é chamado com o valor hasFocus passou como falso. Na versão android antes das 5, o método onPause costumava ser chamado ao pressionar o botão do aplicativo recente.

2. Quando uma atividade pop-up aparece sobre sua atividade, como mencionado por Malcolm , o botão onPause é chamado. Se uma nova atividade que ocupa a tela inteira for chamada, o onStop será chamado na atividade anterior. A caixa de diálogo de permissão do Android também faz com que sua atividade seja chamada de Pausa.

3)Se o tempo limite da tela expirar em sua atividade, a onPause será chamada. Depois de algum tempo, se você não abrir a tela, o onStop será chamado.

Também uma coisa importante mencionada pelo ateiob que completa a resposta

Uma atividade em pausa está completamente ativa (mantém todas as informações de estado e membro e permanece anexada ao gerenciador de janelas). Uma atividade parada também retém todas as informações de estado e membro, mas não está mais anexada ao gerenciador de janelas

Espero que ajude.

sempre que uma nova atividade inicia, a atividade anterior onPauseserá chamada de forma desafiadora em qualquer circunstância.

na verdade, haverá duas circunstâncias:

1 - uma parte da atividade anterior é visível ou a nova atividade é transparente: somente onPauseserá chamada.

2- a atividade anterior é completamente coberta por uma nova atividade: ambas onPausee onStopserão chamadas

---- Bom afirmar algumas notas:

NOTA 1: se uma caixa de diálogo iniciar em cima de uma atividade NENHUMA onPauseou onStopserá chamada.

NOTA 2: se for uma atividade cujo tema está definido como um diálogo, o comportamento será como uma atividade normal.

NOTA 3: aparentemente, uma caixa de diálogo do sistema, como a de permissão, já que o marshmallow causará onPause.

Sim, eu tento entender e posso explicar isso abaixo:

Existem 2 atividades: AtividadeA e AtividadeB

public class ActivityA extends Activity implements OnClickListener {

// button
private Button mBtnChangeActivity;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_a);
    initialize();
    setEvent();
}

private void initialize() {
    Log.i("Activity A", "Initialize()");
    mBtnChangeActivity = (Button) findViewById(R.id.btn_change_activity);
}

private void setEvent() {
    Log.i("Activity A", "setEvent()");
    mBtnChangeActivity.setOnClickListener(this);
}

@Override
protected void onStart() {
    super.onStart();
    Log.i("Activity A", "onStart");
}

@Override
protected void onResume() {
    super.onResume();
    Log.i("Activity A", "onResume");
}

@Override
protected void onPause() {
    super.onPause();
    Log.i("Activity A", "onPause");
}

@Override
protected void onStop() {
    super.onStop();
    Log.i("Activity A", "onStop");
}

@Override
protected void onDestroy() {
    super.onDestroy();
    Log.i("Activity A", "onDestroy");
}

@Override
public void onClick(View v) {
    switch (v.getId()) {
    case R.id.btn_change_activity:
        Intent activityB = new Intent(this, ActivityB.class);
        startActivity(activityB);
        break;
    default:
        break;
    }
}

Aqui está a atividade B. Siga meu comentário no código

public class ActivityB extends Activity implements OnClickListener {

// button
private Button mBtnChangeActivity;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_a);
    initialize();
    setEvent();
    // if call finish() here, activityA will don't stop, just pause
    // Activity A will call onStop() when Activity B call onStart() method
    finish();
}

private void initialize() {
    Log.i("Activity B", "Initialize()");
    mBtnChangeActivity = (Button) findViewById(R.id.btn_change_activity);
}

private void setEvent() {
    Log.i("Activity B", "setEvent()");
    mBtnChangeActivity.setOnClickListener(this);
}

@Override
protected void onStart() {
    super.onStart();
    Log.i("Activity B", "onStart");
}

@Override
protected void onResume() {
    super.onResume();
    Log.i("Activity B", "onResume");
}


@Override
public void onClick(View v) {
    switch (v.getId()) {
    case R.id.btn_change_activity:
        finish();
        break;
    default:
        break;
    }
}
}

Espero que isso seja claramente