Android: Clear Activity Stack

Estoy teniendo varias actividades en mi aplicación. y el flujo es muy complicado. Cuando hago clic en la aplicación Cerrar sesión, navega a la pantalla de inicio de sesión y desde allí el usuario puede salir presionando el botón cancelar (llamando system.exit(0))

cuando salgo o retrocedo, el sistema invoca una actividad de la pila :( ¿cómo puedo borrar todas las actividades en la pila cuando llego a la pantalla de inicio de sesión? llamar finish()no es práctico ya que hay tantas actividades y algunas actividades no deberían cerrarse cuando están activos, como la actividad de invocación de cámara 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);

La mayoría de ustedes está equivocado. Si desea cerrar la pila de actividades existente independientemente de lo que haya allí y crear una nueva raíz, el conjunto correcto de indicadores es el siguiente:

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

Desde el documento :

public static final int FLAG_ACTIVITY_CLEAR_TASK
Agregado en API nivel 11

Si se establece en un Intento pasado Context.startActivity(), este indicador hará que cualquier tarea existente que esté asociada con la actividad se borre antes de que se inicie la actividad. Es decir, la actividad se convierte en la nueva raíz de una tarea que de otro modo estaría vacía, y las actividades antiguas se completan. Esto solo se puede usar junto con FLAG_ACTIVITY_NEW_TASK.

Cuando llamas startActivitya la última actividad, siempre puedes usar

Intent.FLAG_ACTIVITY_CLEAR_TOP

como una bandera en ese intento.

Lea más sobre la bandera aquí .

Aquí hay un método auxiliar simple para comenzar una nueva actividad como la nueva actividad principal que funciona desde el nivel 4 de API hasta la versión 17 actual:

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);
}

llámalo así desde tu actividad actual:

startNewMainActivity(this, MainActivity.class);

Borrar Actividad Backstate con el siguiente código:

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

Hecho

En mi caso, LoginActivity también se cerró. Como resultado,

Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK

no ayudó.

Sin embargo, la configuración

Intent.FLAG_ACTIVITY_NEW_TASK

me ayudó.

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

Noté que solicitó una solución en la que no se basa finish(), pero me pregunto si esto puede ayudar de todos modos.

Rastreé si se levanta un indicador de salida con una variable de clase estática, que sobrevive a toda la vida útil de la aplicación. En cada actividad relevanteonResume() , use

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

La clase ExitHelper

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

Digamos que en mainActivity, un usuario presiona un botón para salir; puede configurarlo ExitHelper.isExitFlagRaised = true;y luego finish(). A partir de entonces, también se terminarán otras actividades relevantes que se reanuden automáticamente.

Esta decisión funciona bien:

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

Pero la nueva actividad se inicia por mucho tiempo y ves una pantalla en blanco en algún momento. Si esto es crítico, utilice esta solución 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();
    }
}

Cómo usarlo:

public class ActivityA extends BaseActivity {

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

Desventaja: todas las actividades que deben cerrarse en la pila deben extender BaseActivity

Para los desarrolladores de Xamarin, puede usar:

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

Usando Kotlin:

Puede establecer la bandera directamente utilizando el método setter. En Kotlin se orencuentra el reemplazo para Java o bit a bit |.

intent.flags = FLAG_ACTIVITY_NEW_TASK or FLAG_ACTIVITY_CLEAR_TASK

Si planea usar esto regularmente, cree una función de extensión de intención

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

Luego puede llamar directamente a esta función antes de comenzar la intención

intent.clearStack()