É possível iniciar uma atividade na pilha, limpando todo o histórico antes dela?

A situação

Eu tenho uma pilha de atividades que vai A-> B-> C ou B-> C (a tela A seleciona o token de usuário, mas muitos usuários têm apenas um único token).

Na tela C, o usuário pode executar uma ação que invalida a tela B; portanto, o aplicativo deseja levá-los para a tela A, independentemente de já estar na pilha. A tela A deve ser o único item da pilha no meu aplicativo.

Notas

Existem muitas outras perguntas semelhantes, mas não encontrei nada que responda a essa pergunta exata. Tentei ligar getParent().finish()- isso sempre resulta em uma exceção de ponteiro nulo. FLAG_ACTIVITY_CLEAR_TOPsó funciona se a atividade já estiver na pilha.

No nível 11 da API, um novo sinalizador de intenção foi adicionado apenas para isso: Intent.FLAG_ACTIVITY_CLEAR_TASK

Apenas para esclarecer, use o seguinte:

Java

intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);

Kotlin

intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK

Infelizmente para a API lvl <= 10, ainda não encontrei uma solução limpa para isso. A solução "DontHackAndroidLikeThis" é de fato pura invasão. Você não deveria fazer isso. :)

Edit: Conforme o comentário de @ Ben Pearson , para a API <= 10 agora é possível usar a classe IntentCompat da mesma forma. Pode-se usar a IntentCompat.FLAG_ACTIVITY_CLEAR_TASKbandeira para limpar a tarefa. Assim, você também pode oferecer suporte ao nível 11 da pré-API.

Caso 1: Apenas duas atividades A e B:

Aqui o fluxo da atividade é A-> B. Ao clicar no botão voltar de B, precisamos fechar o aplicativo e, ao iniciar a atividade B a partir de A, basta concluir (), isso impedirá o android de armazenar a atividade A no Backstack.eg para a atividade A Tela Loding / Splash do aplicativo.

Intent newIntent = new Intent(A.this, B.class);
startActivity(newIntent);
finish();

Caso 2: Mais de duas atividades:

Se houver um fluxo como A-> B-> C-> D-> B e clicar no botão Voltar na Atividade B enquanto estiver vindo da Atividade D. Nesse caso, devemos usar.

Intent newIntent = new Intent(D.this,B.class);
newIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
newIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(newIntent);

Aqui, a Atividade B será iniciada a partir do backstack em vez de uma nova instância por causa do Intent.FLAG_ACTIVITY_CLEAR_TOP e Intent.FLAG_ACTIVITY_NEW_TASK limpa a pilha e a torna a primeira.

Com a versão mais recente do Android> = API 16, use finishAffinity()

abordagem é adequada para> = API 16.

Intent mIntent = new Intent(mContext,MainActivity.class);
finishAffinity();
startActivity(mIntent);

• É o mesmo que iniciar uma nova atividade e limpar toda a pilha.
• OU Reinicie em MainActivity / FirstActivity.

Também passei algumas horas nisso ... e concordo que FLAG_ACTIVITY_CLEAR_TOP soa como o que você deseja: limpe toda a pilha, exceto a atividade que está sendo iniciada, para que o botão Voltar saia do aplicativo. No entanto, como Mike Repass mencionou, FLAG_ACTIVITY_CLEAR_TOP só funciona quando a atividade que você está iniciando já está na pilha; quando a atividade não está lá, a bandeira não faz nada.

O que fazer? Coloque a atividade sendo iniciada na pilha com FLAG_ACTIVITY_NEW_TASK, que torna essa atividade o início de uma nova tarefa na pilha de histórico. Em seguida, adicione o sinalizador FLAG_ACTIVITY_CLEAR_TOP.

Agora, quando FLAG_ACTIVITY_CLEAR_TOP for encontrar a nova atividade na pilha, ela estará lá e será exibida antes que todo o resto seja limpo.

Aqui está a minha função de logout; o parâmetro View é o botão ao qual a função está conectada.

public void onLogoutClick(final View view) {
    Intent i = new Intent(this, Splash.class);
    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    startActivity(i);
    finish();
}

Você não deve mudar a pilha. O botão Voltar do Android deve funcionar como em um navegador da web.

Eu posso pensar em uma maneira de fazer isso, mas é um truque.

• Faça suas atividades singleTaskadicionando-as ao AndroidManifest exemplo:

  <activity android:name=".activities.A"
            android:label="@string/A_title"
            android:launchMode="singleTask"/>
  
  <activity android:name=".activities.B"
            android:label="@string/B_title"
            android:launchMode="singleTask"/>

• Estenda o Applicationque manterá a lógica de onde ir.

Exemplo:

public class DontHackAndroidLikeThis extends Application {

  private Stack<Activity> classes = new Stack<Activity>();

  public Activity getBackActivity() {
    return classes.pop();
  }

  public void addBackActivity(Activity activity) {
    classes.push(activity);
  }
}

De a para B:

DontHackAndroidLikeThis app = (DontHackAndroidLikeThis) getApplication();
app.addBackActivity(A.class); 
startActivity(this, B.class);

De B ​​a C:

DontHackAndroidLikeThis app = (DontHackAndroidLikeThis) getApplication();
app.addBackActivity(B.class); 
startActivity(this, C.class);

Em C:

If ( shouldNotGoBackToB() ) {
  DontHackAndroidLikeThis app = (DontHackAndroidLikeThis) getApplication();
  app.pop();
}

e segure o botão voltar para pop() da pilha.

Mais uma vez, você não deve fazer isso :)

Imediatamente após iniciar uma nova atividade, use startActivity, certifique-se de ligar finish()para que a atividade atual não fique empilhada atrás da nova.

Tente o seguinte:

Intent logout_intent = new Intent(DashboardActivity.this, LoginActivity.class);
logout_intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
logout_intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
logout_intent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
startActivity(logout_intent);
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ê planeja usá-lo regularmente, 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
}

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

Experimente o código abaixo,

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

Para mim, nenhum dos métodos acima não funciona.

Faça isso para limpar todas as atividades anteriores :

finishAffinity() // if you are in fragment use activity.finishAffinity()
Intent intent = new Intent(this, DestActivity.class); // with all flags you want
startActivity(intent)

Às vezes, o emulador do Android pode não conseguir conectar a ferramenta DDMS do eclipse e solicitar que o adb seja iniciado manualmente. Nesse caso, você pode iniciar ou parar o adb usando o prompt de comando.

Eu achei um hack muito simples, basta fazer isso, adicionar um novo elemento AndroidManifestcomo: -

<activity android:name=".activityName"
          android:label="@string/app_name"
          android:noHistory="true"/>

o android:noHistorylimpará sua atividade indesejada do Stack.