Android: limpe a pilha traseira

No Android, eu tenho algumas atividades, digamos A, B, C.

Em A, eu uso esse código para abrir B:

Intent intent = new Intent(this, B.class);
startActivity(intent);

Em B, eu uso esse código para abrir C:

Intent intent = new Intent(this, C.class);
startActivity(intent);

Quando o usuário toca em um botão em C, quero voltar para A e limpar a pilha de trás (feche B e C). Portanto, quando o usuário usar o botão voltar B e C não será exibido, tentei o seguinte:

Intent intent = new Intent(this, A.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
startActivity(intent);

Mas B e C ainda estão aparecendo se eu usar o botão voltar quando volto à atividade A. Como posso evitar isso?

Tente adicionar FLAG_ACTIVITY_NEW_TASKconforme descrito nos documentos para FLAG_ACTIVITY_CLEAR_TOP:

Esse modo de inicialização também pode ser usado com bom efeito em conjunto com FLAG_ACTIVITY_NEW_TASK: se usado para iniciar a atividade raiz de uma tarefa, ele trará qualquer instância dessa tarefa em execução no momento para o primeiro plano e depois a limpará para o estado raiz. Isso é especialmente útil, por exemplo, ao iniciar uma atividade do gerenciador de notificações.

Portanto, seu código para iniciar Aseria:

Intent intent = new Intent(this, A.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK); 
startActivity(intent);
CurrentActivity.this.finish(); // if the activity running has it's own context


// view.getContext().finish() for fragments etc.

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);

Que tal adicionar no arquivo manifestos para atividades relacionadas:

android:noHistory="true"

para a definição de atividade de B e C? Eles não serão adicionados ao backstack. Não tenho certeza se é isso que você deseja.

Isso me incomoda por um longo tempo. Finalmente, resolvi fazer isso:

No fragmento, use:

Intent intent = new Intent(view.getContext(), A.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK); 
startActivity(intent);

Em Atividade, use (adicione mais um sinalizador de intenção Intent.FLAG_ACTIVITY_CLEAR_TASKcomparado ao fragmento):

Intent intent = new Intent(this, MainActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

1. Adicione android:launchMode="singleTop"ao elemento de atividade no seu manifesto a Atividade A
2. Em seguida, use intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP) e intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)ao iniciar a Atividade A

Isso significa que, quando a Atividade A é iniciada, todas as tarefas sobre ela são limpas para que A seja a primeira. Uma nova pilha traseira é criada com A na raiz, e o uso singleTopgarante que você só inicie A uma vez (já que A está no topo devido a ..._CLEAR_TOP).

A partir da API 16 (Jelly Bean), você pode simplesmente ligar finishAffinity().

Agora você também pode ligar ActivityCompat.finishAffinity(Activity activity)com a biblioteca de compatibilidade.

Certifique-se de definir taskAffinity no manifesto como um nome de pacote exclusivo para esse grupo de atividades.

Consulte para obter mais informações:
http://developer.android.com/reference/android/support/v4/app/ActivityCompat.html#finishAffinity%28android.app.Activity%29

Tente usar

intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);

e não

intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);

Se o seu aplicativo tiver uma versão mínima do sdk 16, você poderá usar finishAffinity ()

Conclua esta atividade e todas as atividades imediatamente abaixo dela na tarefa atual que possui a mesma afinidade.

Isso é bom para mim. Na tela Pagamento principal, remova todas as atividades de pilha traseira,

 @Override
public void onBackPressed() {
         finishAffinity();
        startActivity(new Intent(PaymentDoneActivity.this,Home.class));
    } 

http://developer.android.com/reference/android/app/Activity.html#finishAffinity%28%29

Conforme Wakka em Removendo uma atividade da pilha do histórico ...

Adicionar android:noHistory="true"atributo para o seu <activity>no AndroidManifest.xmlassim:

    <activity android:name=".MyActivity"
        android:noHistory="true">
    </activity>

Para pesquisas futuras, tente este código.

Intent intent = new Intent(context, LoginActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
finish();

Use finishAffinity (); na tarefa C ao iniciar a tarefa A para limpar as atividades de backstack.

Use este código para iniciar uma nova atividade e feche ou destrua todas as outras pilhas de atividades ou pilhas de volta.

Intent intent = new Intent(this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);

Use finishAffinity() to clear all backstack with existing one.

Suppose, Activities A, B and C are in stack, and finishAffinity(); is called in Activity C, 

    - Activity B will be finished / removing from stack.
    - Activity A will be finished / removing from stack.
    - Activity C will finished / removing from stack.

Encontrei uma solução interessante que pode ajudar. Eu fiz isso no meu onBackPressed()método.

finishAffinity();
finish();

FinishAffinityremove a conexão da atividade existente à sua pilha. E, em seguida, terminar ajuda a sair dessa atividade. O que acabará saindo do aplicativo.

Eu achei as respostas aqui um pouco enganadoras, porque o código na pergunta original parece funcionar bem para mim?

Como A é a atividade raiz, iniciá-la em B ou C somente com FLAG_ACTIVITY_CLEAR_TOP remove B e C da pilha traseira.

No kotlin, é quase o mesmo que o java. Apenas | símbolo é substituído por ou texto. Então, está escrito como-

intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK)

Eu tentei todas as soluções e nenhuma funcionou individualmente para mim. Minha solução é:

Declarar Activity Acomo SingleTopusando [android:launchMode="singleTop"]no manifesto do Android.

Agora adicione os seguintes sinalizadores ao iniciar Ade qualquer lugar. Isso limpará a pilha.

Intent in = new Intent(mContext, A.class);
in.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK );
startActivity(in);
finish();

Intent.FLAG_ACTIVITY_CLEAR_TOPnão funcionará neste caso. Por favor, use(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK)

Para mais detalhes, consulte esta documentação.

Parece-me que você precisa para começar Activity Ca partir Activity Busando startActivityForResult(). Quando você clica em um botão em Activity C, chamada setResult(RESULT_OK)e finish()assim Activity Cterminou. Em Activity B, você pode ter a onActivityResult()resposta também chamando finish()a si próprio e depois será levado de volta para Activity A.

logout.addFlags (Intent.FLAG_ACTIVITY_CLEAR_TASK); logout.addFlags (Intent.FLAG_ACTIVITY_NEW_TASK);

Você pode usar este exemplo para chamar a sua Activity AdeActivity C

Intent loout = new Intent(context, LoginActivity.class); loout.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); context.startActivity(loout);

para mim adicionando Intent.FLAG_ACTIVITY_CLEAR_TASKresolveu o problema

Intent i = new Intent(SettingsActivity.this, StartPage.class);
                i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP  | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(i);
finish();

Kotlin reutilizável avançado:

Você pode definir o sinalizador diretamente usando o método setter. No Kotlin oré o substituto para o Java bit a bit ou |.

intent.flags = FLAG_ACTIVITY_NEW_TASK or FLAG_ACTIVITY_CLEAR_TASK

Se você usar isso mais de uma vez, crie uma função de extensão Intent

fun Intent.clearStack() {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}

Você pode chamar diretamente essa função antes de iniciar a intenção

intent.clearStack()

Se você precisar adicionar outros sinalizadores em outras situações, adicione um parâmetro opcional à função de extensão.

fun Intent.clearStack(additionalFlags: Int = 0) {
    flags = additionalFlags or Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}

Além disso FLAG_ACTIVITY_CLEAR_TOP, você pode tentar adicionar Intent.FLAG_ACTIVITY_SINGLE_TOPtambém:

intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

O código fornecido funciona corretamente. Eu tentei na amostra do ciclo de vida do aplicativo.

Não tenho B e C na pilha de trás após iniciar a atividade A com o sinalizador FLAG_ACTIVITY_CLEAR_TOP

liguei activity_name.this.finish()depois de iniciar uma nova intenção e funcionou para mim.

I tried "FLAG_ACTIVITY_CLEAR_TOP" and "FLAG_ACTIVITY_NEW_TASK"

Mas isso não funcionará para mim ... Eu não estou sugerindo esta solução para uso, mas se a configuração do sinalizador não funcionar para você, você pode tentar isso ... mas ainda assim eu recomendo não usá-lo

Adicionar NO Flag Flag na intenção.

Na atividade B, inicie a atividade C como abaixo >>>>>>

Intent intent = new Intent(this, C.class);
intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NO_HISTORY); 
startActivity(intent);
finish();

Em manifesto

android:launchMode="singleTask"

e

intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

Adicione isso ao seu Activity BeActivity C

android:noHistory="true"

ou Override onBackPressedfunção para evitar pressionar novamente com a return.

@Override
public void onBackPressed() {
   return;
}

Use o método setFlags () para que o verso claro abra todas as atividades feche e inicie sua atividade

Intent intent = new Intent(getApplicationContext(), yourActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);