segundo - quitar anuncios de aplicaciones android

Cómo salir de la aplicación de Android programáticamente

Question

Encontré algunos códigos para salir de una aplicación de Android programáticamente. Al llamar a cualquiera de los siguientes códigos en onDestroy (), ¿se cerrará la aplicación completamente?

1. System.runFinalizersOnExit(true)
   (O)
2. android.os.Process.killProcess(android.os.Process.myPid());

No quiero ejecutar mi aplicación en segundo plano después de hacer clic en el botón Salir. Por favor, sugiérame, ¿puedo usar cualquiera de estos códigos para salir de mi aplicación? Si es así, ¿qué código puedo usar? ¿Es una buena manera de salir de la aplicación en Android?

Answer 1

Cree un ExitActivity y declare en manifiesto. Y llame a ExitActivity.exit(context) para salir de la aplicación.

public class ExitActivity extends AppCompatActivity {

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

    public static void exit(Context context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
        context.startActivity(intent);
    }

}

Answer 2

Creo que la aplicación debería ser matar en algún caso. Por ejemplo, hay una aplicación que se puede usar solo después de iniciar sesión. La actividad de inicio de sesión tiene dos botones, ''inicio de sesión'' y ''cancelar''. Cuando hace clic en el botón ''cancelar'', definitivamente significa ''terminar la aplicación''. Nadie quiere que la aplicación viva en el fondo. Así que estoy de acuerdo en que algunos casos necesitan cerrar la aplicación.

Answer 3

Creo que lo que buscas es esto.

activity.moveTaskToBack(Boolean nonRoot);

Answer 4

De su actividad de alto nivel:

super.onBackPressed();

Answer 5

Depende de qué tan rápido quieras cerrar tu aplicación.

Una forma segura de cerrar su aplicación es finishAffinity ();

Cierra tu aplicación después de que todos los procesos hayan terminado de procesarse. Esto puede necesitar algo de tiempo. Si cierra la aplicación de esta manera y la reinicia poco después, es posible que la nueva aplicación se ejecute en el mismo proceso. Con todos los procesos no terminados y objetos singleton de la aplicación anterior.

Si desea estar seguro, que su aplicación está cerrada completamente, use System.exit (0);

Esto cerrará su aplicación inmediatamente. Pero es posible que dañes los archivos que tu aplicación ha abierto o que una edición en las preferencias compartidas no termine. Así que usa esto con cuidado.

Si usa la vigilancia en combinación con una tarea de ejecución prolongada, puede ver las influencias de los diferentes métodos.

new ANRWatchDog(2000).setANRListener(new ANRWatchDog.ANRListener() {
    public void onAppNotResponding(ANRError error) {
        MainActivity.this.finishAffinity();
        System.exit(0);
    }
}).start();
for(int i = 0; i < 10; ++i){
    --i;
}

Esto mata tu aplicación después de 2 segundos sin mostrar un cuadro de diálogo ANR o algo así. Si elimina System.exit (0) , ejecute este código y reinicie la aplicación después de que se cierre, experimentará algún comportamiento extraño, porque el bucle sin fin todavía se está ejecutando.

Answer 6

Desde la API 16 puede usar el método finishAffinity, que parece estar muy cerca de cerrar todas las actividades relacionadas por su nombre y descripción de Javadoc:

this.finishAffinity ();

Termine esta actividad así como todas las actividades inmediatamente debajo de ella en la tarea actual que tienen la misma afinidad. Esto generalmente se usa cuando una aplicación se puede iniciar en otra tarea (por ejemplo, desde un ACTION_VIEW de un tipo de contenido que comprende) y el usuario ha usado la navegación hacia arriba para cambiar de la tarea actual a su propia tarea. En este caso, si el usuario ha navegado hacia abajo en cualquier otra actividad de la segunda aplicación, todas esas deben eliminarse de la tarea original como parte del interruptor de tarea.

Tenga en cuenta que este final no le permite entregar resultados a la actividad anterior, y se lanzará una excepción si está intentando hacerlo.

Desde API 21 puedes usar un comando muy similar

finishAndRemoveTask ();

Finaliza todas las actividades en esta tarea y las elimina de la lista de tareas recientes.

Answer 7

En primer lugar, este enfoque requiere min Api 16.

Dividiré esta solución en 3 partes para resolver este problema más ampliamente.

1. Si desea salir de la aplicación en una actividad, use este fragmento de código:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
            finishAffinity();
        } else if(Build.VERSION.SDK_INT>=21){
            finishAndRemoveTask();
        }

2. Si desea salir de la aplicación en una clase que no sea de actividad que tenga acceso a la actividad, use este fragmento de código:

    if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                getActivity().finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                getActivity().finishAndRemoveTask();
            }

3. Si desea salir de la aplicación en una clase que no sea de Actividad y no puede acceder a la Actividad como Servicio, le recomiendo que use BroadcastReceiver. Puede agregar este enfoque a todas sus actividades en su proyecto.

Crear las variables de instancia LocalBroadcastManager y BroadcastReceiver. Puede reemplazar getPackageName () + ". Closeapp" si lo desea.

LocalBroadcastManager mLocalBroadcastManager;
BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getAction().equals(getPackageName()+".closeapp")){
            if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                finishAndRemoveTask();
            }
        }
    }
};

Agréguelos al método de actividad onCreate ().

    mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
    IntentFilter mIntentFilter = new IntentFilter();
    mIntentFilter.addAction(getPackageName()+".closeapp");
    mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, mIntentFilter);

Además, no olvide llamar a anular el registro en el método de actividad onDestroy ()

    mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Para salir de la aplicación, debe enviar la difusión utilizando LocalBroadcastManager que uso en mi clase PlayService que extiende el Servicio.

  LocalBroadcastManager localBroadcastManager = LocalBroadcastManager
                                .getInstance(PlayService.this);
                        localBroadcastManager.sendBroadcast(new Intent(
                                getPackageName() + ".closeapp"));

Answer 8

Escriba este código en su método de anulación en backpressed

@Override
public void onBackPressed() {
    Intent intent = new Intent(Intent.ACTION_MAIN);
    intent.addCategory(Intent.CATEGORY_HOME);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    startActivity(intent);
}

Answer 9

Esto matará cualquier cosa;)

int p = android.os.Process.myPid();
android.os.Process.killProcess(p);

Answer 10

Esto puede ser muy tarde y también según las pautas que no debe manejar usted mismo el proceso del ciclo de vida (ya que el sistema operativo lo hace por usted). Una sugerencia sería que registre un receptor de transmisión en todas sus actividades con " finish() " en su onReceive() y cada vez que desee abandonar puede pasar un intento indicando que todas las actividades deben cerrarse ... Aunque asegúrese de "anular el registro" del receptor en sus métodos onDestroy() .

Answer 11

La forma más fácil que encontré para abandonar una aplicación de una actividad, sin romper la lógica de Android y sin agregar más código en actividades existentes y aprobar extras es la siguiente:

public static void quitApplication (Activity currentActivity) {
    Intent intent = new Intent (currentActivity, QuitApplicationActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);

    currentActivity.startActivity (intent);
    currentActivity.finish ();
}

siendo QuitApplicationActivity :

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

Answer 12

La solución correcta y exacta para salir de la aplicación al hacer clic en el botón es usar el siguiente código:

// On Button Back evento presionado

public void onBackPressed()
{ 
   moveTaskToBack(true);
   finish();
}

Answer 13

Manera fácil y sencilla de salir de la aplicación.

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);

Answer 14

No es una buena decisión, porque va en contra de los principios de procesamiento de aplicaciones de Android. Android no mata ningún proceso a menos que sea absolutamente inevitable. Esto ayuda a que las aplicaciones se inicien más rápido, ya que siempre se guardan en la memoria. Así que necesitas una razón muy especial para matar el proceso de tu aplicación.

Answer 15

No estoy seguro de si esto está mal visto o no, pero así es como lo hago ...

Paso 1: normalmente tengo una clase que contiene métodos y variables a las que quiero acceder globalmente. En este ejemplo lo llamaré la clase "App". Cree una variable de actividad estática dentro de la clase para cada actividad que tenga su aplicación. Luego cree un método estático llamado "cerrar" que ejecutará el método finish() en cada una de esas variables de Actividad si NO son nulas . Si tienes una actividad principal / principal, ciérrala al final:

public class App
{
    ////////////////////////////////////////////////////////////////
    // INSTANTIATED ACTIVITY VARIABLES
    ////////////////////////////////////////////////////////////////

        public static Activity activity1;
        public static Activity activity2;
        public static Activity activity3;

    ////////////////////////////////////////////////////////////////
    // CLOSE APP METHOD
    ////////////////////////////////////////////////////////////////

        public static void close()
        {
            if (App.activity3 != null) {App.activity3.finish();}
            if (App.activity2 != null) {App.activity2.finish();}
            if (App.activity1 != null) {App.activity1.finish();}
        }
}

Paso 2: en cada una de sus actividades, anule los onStart() y onDestroy() . En onStart() , establezca la variable estática en su clase de aplicación igual a " this ". En onDestroy() , onDestroy() igual a null . Por ejemplo, en la clase "Activity1":

@Override
public void onStart()
{
    // RUN SUPER | REGISTER ACTIVITY AS INSTANTIATED IN APP CLASS

        super.onStart();
        App.activity1 = this;
}

@Override
public void onDestroy()
{
    // RUN SUPER | REGISTER ACTIVITY AS NULL IN APP CLASS

        super.onDestroy();
        App.activity1 = null;
}

Paso 3: cuando desee cerrar su aplicación, simplemente llame a App.close() desde cualquier lugar. ¡Todas las actividades instanciadas se cerrarán! Dado que solo está cerrando actividades y no está matando a la aplicación en sí (como en sus ejemplos), Android es libre de tomar el control desde allí y hacer la limpieza necesaria.

Una vez más, no sé si esto sería mal visto por alguna razón. Si es así, me encantaría leer los comentarios sobre por qué es y cómo se puede mejorar.

Answer 16

Para salir de tu aplicación puedes usar lo siguiente:

getActivity().finish();
Process.killProcess(Process.myPid());
System.exit(1);

También para detener los servicios también llame al siguiente método:

private void stopServices() {        
    final ActivityManager activityManager = SystemServices.getActivityManager(context);
    final List<ActivityManager.RunningServiceInfo> runningServices = activityManager.getRunningServices(Integer.MAX_VALUE);
    final int pid = Process.myPid();
    for (ActivityManager.RunningServiceInfo serviceInfo : runningServices) {
        if (serviceInfo.pid == pid && !SenderService.class.getName().equals(serviceInfo.service.getClassName())) {
            try {
                final Intent intent = new Intent();
                intent.setComponent(serviceInfo.service);
                context.stopService(intent);
            } catch (SecurityException e) { 
                 // handle exception
            }
        }
    }
}

Answer 17

Por favor, piense muy bien si necesita eliminar la aplicación: ¿por qué no dejar que el sistema operativo averigüe dónde y cuándo liberar los recursos?

De lo contrario, si está absolutamente seguro, use

finish();

Como reacción al comentario de @dave appleton: Lo primero que leyó el gran combo de preguntas / respuestas @gabriel fue publicado: ¿Está mal frenar una aplicación?

Ahora, asumiendo que tenemos eso, la pregunta aquí todavía tiene una respuesta, ya que el código que necesita si está haciendo algo para dejar de fumar es finish() . Obviamente, puedes tener más de una actividad, etc., etc., pero ese no es el punto. Vamos a correr por algunos de los casos de uso.

1. Desea permitir que el usuario salga de todo debido al uso de la memoria y "¿no se ejecuta en segundo plano? Duda. Permita que el usuario detenga ciertas actividades en segundo plano, pero deje que el sistema operativo elimine cualquier recurso innecesario.
2. ¿Quieres que un usuario no vaya a la actividad anterior de tu aplicación? Bueno, o bien configúrelo para que no lo haga, o necesita una opción adicional. Si la mayoría de las veces, la actividad anterior = atrás funciona, ¿no debería el usuario presionar Inicio si quiere hacer otra cosa?
3. Si necesita algún tipo de restablecimiento, puede averiguar si / cómo / etc se abandonó su aplicación, y si su actividad vuelve a concentrarse, puede actuar al respecto, mostrando una pantalla nueva en lugar de reiniciar donde estaba.

Así que al final, por supuesto, finish() no mata todo, pero creo que sigue siendo la herramienta que necesitas. Si hay un caso de uso para "matar todas las actividades", todavía no lo he encontrado.

Answer 18

Prueba esto

int pid = android.os.Process.myPid();
android.os.Process.killProcess(pid);

Answer 19

Puedes usar finishAndRemoveTask () desde API 21

public void finishAndRemoveTask ()

Finaliza todas las actividades en esta tarea y las elimina de la lista de tareas recientes.

Answer 20

Será mejor que uses finish() si estás en Activity , o getActivity().finish() si estás en el Fragment .

Si desea salir completamente de la aplicación, use:

getActivity().finish();
System.exit(0);

Answer 21

Simplemente use finish () en la tecla de retroceso, presione onKeypressed ()

Answer 22

Usted puede dejar sus aplicaciones completas. así

Intent intent = getBaseContext().getPackageManager()
             .getLaunchIntentForPackage(getBaseContext().getPackageName());
intent .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

Funcionará al 100%. ¡La mejor de las suertes!

Answer 23

¿Está mal visto dejar una aplicación? . Ir a través de este enlace. Responde a tu pregunta. El sistema hace el trabajo de matar una aplicación.

Supongamos que tiene dos actividades A y B. Usted navega de A a B. Cuando hace clic en el botón Atrás, su actividad B aparece en la parte de atrás y se destruye. Actividad previa en la actividad de la pila trasera A toma el foco.

Debe dejarlo en el sistema para decidir cuándo anular la aplicación.

finish() vacío público finish()

Llame a esto cuando su actividad esté terminada y debe cerrarse.

Supongamos que tienes muchas actividades. Puedes usar la barra de acción. Al hacer clic en el icono de inicio, navegue a MainActivity de su aplicación. En MainActivity, haga clic en el botón Atrás para salir de la aplicación.

Answer 24

finishAffinity();

System.exit(0);

Si va a utilizar solo finishAffinity(); sin System.exit(0); su aplicación se cerrará pero la memoria asignada seguirá siendo utilizada por su teléfono, así que ... si desea una aplicación limpia y realmente cerrada, use ambas.

Este es el método más simple y funciona en cualquier lugar, salga de la aplicación de verdad, puede tener una gran cantidad de actividad abierta y todo saldrá sin problemas.

ejemplo en un botón haga clic

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

o si desea algo agradable, ejemplo con un cuadro de diálogo de alerta con 3 botones SÍ NO y CANCELAR

// alertdialog for exit the app
AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);

// set the title of the Alert Dialog
alertDialogBuilder.setTitle("your title");

// set dialog message
alertDialogBuilder
        .setMessage("your message")
        .setCancelable(false)
        .setPositiveButton("YES"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // what to do if YES is tapped
                        finishAffinity();
                        System.exit(0);
                    }
                })

        .setNeutralButton("CANCEL"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on CANCEL tapped
                        dialog.cancel();
                    }
                })

        .setNegativeButton("NO"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on NO tapped
                        dialog.cancel();
                    }
                });

AlertDialog alertDialog = alertDialogBuilder.create();

alertDialog.show();

Answer 25

No hay ninguna aplicación que cierre en Android , SampleActivity.this.finish (); Terminará la actividad actual.

Cuando cambias de una actividad a otra, continúa con la anterior.

Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
startActivity(homeintent);
SampleActivity.this.finish();

Answer 26

getActivity().finish();
System.exit(0);

Esta es la mejor manera de salir de tu aplicación. !!!

La mejor solución para mí.

Answer 27

public void quit() {
        int pid = android.os.Process.myPid();
        android.os.Process.killProcess(pid);
        System.exit(0);
    }