Android: Limpar pilha de atividades

Estou tendo várias atividades no meu aplicativo. e o fluxo é muito complicado. Quando clico no aplicativo Logout, navega para a tela de login e a partir daí o usuário pode sair pelo botão Cancelar (chamando system.exit(0))

Quando eu saio ou o botão Voltar, o sistema chama uma atividade da pilha :( como posso limpar todas as atividades da pilha quando chego à tela de Login? A chamada finish()não é prática, pois há muitas atividades e algumas atividades não devem ser fechadas quando eles estão ativos, como atividade de chamada de câmera nativa.

validateuser logoutuser = new validateuser();
logoutuser.logOut();
Intent loginscreen = new Intent(homepage.this, Login2.class);
(homepage.this).finish();
loginscreen.setFlags( Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NO_HISTORY);
startActivity(loginscreen);

A maioria de vocês está errada. Se você deseja fechar a pilha de atividades existente, independentemente do que está lá e criar uma nova raiz, o conjunto correto de sinalizadores é o seguinte:

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

Do documento :

public static final int FLAG_ACTIVITY_CLEAR_TASK
Adicionado no nível 11 da API

Se definido em um Intent passado para Context.startActivity(), esse sinalizador fará com que qualquer tarefa existente que esteja associada à atividade seja limpa antes que a atividade seja iniciada. Ou seja, a atividade se torna a nova raiz de uma tarefa vazia e quaisquer atividades antigas são concluídas. Isso só pode ser usado em conjunto com FLAG_ACTIVITY_NEW_TASK.

Quando você liga startActivitypara a última atividade, você sempre pode usar

Intent.FLAG_ACTIVITY_CLEAR_TOP

como uma bandeira nessa intenção.

Leia mais sobre a bandeira aqui .

Aqui está um método auxiliar simples para iniciar uma nova atividade como a nova atividade principal que funciona desde o nível 4 da API até a versão atual 17:

static void startNewMainActivity(Activity currentActivity, Class<? extends Activity> newTopActivityClass) {
    Intent intent = new Intent(currentActivity, newTopActivityClass);
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
        intent.addFlags(0x8000); // equal to Intent.FLAG_ACTIVITY_CLEAR_TASK which is only available from API level 11
    currentActivity.startActivity(intent);
}

chame assim da sua atividade atual:

startNewMainActivity(this, MainActivity.class);

Apague a Atividade Backstate pelo código abaixo:

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

Feito

No meu caso, o LoginActivity também foi fechado. Como um resultado,

Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK

não ajudou.

No entanto, a configuração

Intent.FLAG_ACTIVITY_NEW_TASK

me ajudou.

Intent intent = new Intent(LoginActivity.this, Home.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);  //It is use to finish current activity
startActivity(intent);
this.finish();

Observei que você pediu uma solução que não depende finish(), mas me pergunto se isso pode ajudar.

Rastreei se um sinalizador de saída é gerado com uma variável de classe estática, que sobrevive a vida útil do aplicativo inteiro. Em cada atividade relevanteonResume() , use

@Override
public void onResume() {
    super.onResume();
    if (ExitHelper.isExitFlagRaised) {
        this.finish();
    }
}

A classe ExitHelper

public class ExitHelper {
    public static boolean isExitFlagRaised = false;
}

Digamos que em mainActivity, um usuário pressione um botão para sair - você pode definir ExitHelper.isExitFlagRaised = true;e depois finish(). Depois disso, outras atividades relevantes retomadas automaticamente também serão concluídas.

Esta decisão funciona bem:

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

Mas novas atividades são lançadas por muito tempo e você vê a tela branca em algum momento. Se isso for crítico, use esta solução alternativa:

public class BaseActivity extends AppCompatActivity {

    private static final String ACTION_FINISH = "action_finish";

    private BroadcastReceiver finisBroadcastReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        registerReceiver(finisBroadcastReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                finish();
            }
        }, new IntentFilter(ACTION_FINISH));
    }

    public void clearBackStack() {
        sendBroadcast(new Intent(ACTION_FINISH));
    }

    @Override
    protected void onDestroy() {
        unregisterReceiver(finisBroadcastReceiver);
        super.onDestroy();
    }
}

Como usá-lo:

public class ActivityA extends BaseActivity {

    // Click any button
    public void startActivityB() {
        startActivity(new Intent(this, ActivityB.class));
        clearBackStack();
    }
}

Desvantagem: todas as atividades que devem ser fechadas na pilha devem estender BaseActivity

Para Xamarin Developers, você pode usar:

intent.SetFlags(ActivityFlags.NewTask | ActivityFlags.ClearTask);

Usando o Kotlin:

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()