Come uscire dall'applicazione Android a livello di codice

Ho trovato alcuni codici per uscire da un'applicazione Android a livello di codice. Chiamando uno dei seguenti codici in onDestroy () uscirà completamente dall'applicazione?

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

Non voglio eseguire la mia applicazione in background dopo aver fatto clic sul pulsante Esci. Mi suggerisco di utilizzare uno di questi codici per uscire dalla mia app? In tal caso, quale codice posso usare? È un buon modo per uscire dall'app in Android?

Dall'API 16 puoi utilizzare il metodo finishAffinity, che sembra essere abbastanza vicino alla chiusura di tutte le attività correlate con il suo nome e la descrizione di Javadoc:

this.finishAffinity();

Termina questa attività e tutte le attività immediatamente sottostanti nell'attività corrente che hanno la stessa affinità. Viene in genere utilizzato quando un'applicazione può essere avviata su un'altra attività (ad esempio da un ACTION_VIEW di un tipo di contenuto che comprende) e l'utente ha utilizzato la navigazione verso l'alto per passare dall'attività corrente alla propria attività. In questo caso, se l'utente è passato a un'altra attività della seconda applicazione, tutte queste dovrebbero essere rimosse dall'attività originale come parte del cambio di attività.

Si noti che questa finitura non consente di fornire risultati all'attività precedente e verrà generata un'eccezione se si sta tentando di farlo.

Dall'API 21 puoi usare un comando molto simile

finishAndRemoveTask();

Termina tutte le attività in questa attività e la rimuove dall'elenco delle attività recenti.

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

questo è il modo migliore per uscire dalla tua app. !!!

La migliore soluzione per me

finishAffinity();

System.exit(0);

Se utilizzerai solo finishAffinity();senza che System.exit(0);l'applicazione verrà chiusa, ma la memoria allocata sarà ancora in uso dal tuo telefono, quindi ... se vuoi un'app pulita e davvero uscire da un'app, usa entrambe.

Questo è il metodo più semplice e funziona ovunque, esci dall'app per davvero, puoi avere un sacco di attività aperte che lascerà comunque tutto senza problemi.

esempio con un clic sul pulsante

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

o se vuoi qualcosa di carino, ad esempio con una finestra di avviso con 3 pulsanti SÌ NO e ANNULLA

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

Ti preghiamo di riflettere seriamente se hai bisogno di uccidere l'applicazione: perché non lasciare che il sistema operativo capisca dove e quando liberare le risorse?

Altrimenti, se sei assolutamente sicuro, usa

finish();

Come reazione al commento di @dave appleton: per prima cosa leggi la grande domanda / risposta combinata @gabriel pubblicata: la chiusura di un'applicazione è disapprovata?

Ora supponendo che l'abbiamo, la domanda qui ha ancora una risposta, essendo che il codice che ti serve se stai facendo qualcosa con smettere è finish(). Ovviamente puoi avere più di un'attività ecc. Ecc., Ma non è questo il punto. Consente l'esecuzione di alcuni casi d'uso

1. Si desidera consentire all'utente di chiudere tutto a causa dell'utilizzo della memoria e "non in esecuzione in background? Dubbio. Consentire all'utente di interrompere determinate attività in background, ma lasciare che il sistema operativo uccida qualsiasi ricorso non necessario.
2. Vuoi che un utente non vada all'attività precedente della tua app? Bene, o configuralo in modo che non lo sia, o hai bisogno di un'opzione extra. Se il più delle volte l'attività back = precedente funziona, l'utente non dovrebbe semplicemente premere home se vuole fare qualcos'altro?
3. Se hai bisogno di una sorta di ripristino, puoi scoprire se / come / etc l'applicazione è stata chiusa e se la tua attività viene nuovamente focalizzata puoi agire su quello, mostrando una nuova schermata invece di riavviare dove ti trovavi.

Quindi alla fine, ovviamente, finish()non uccide tutto, ma è ancora lo strumento di cui hai bisogno, penso. Se esiste un caso d'uso per "uccidi tutte le attività", non l'ho ancora trovato.

Penso che l'applicazione dovrebbe essere uccisa in alcuni casi. Ad esempio, esiste un'app che può essere utilizzata solo dopo l'accesso. L'attività di accesso ha due pulsanti, "accedi" e "annulla". Quando si fa clic sul pulsante "Annulla", significa sicuramente "Terminare l'app". Nessuno vuole che l'app sia viva in background. Quindi sono d'accordo sul fatto che alcuni casi debbano chiudere l'app.

Crea un ExitActivitye dichiaralo in manifest. E chiama ExitActivity.exit(context)per uscire dall'app.

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

}

Non è possibile uscire dall'applicazione in Android , SampleActivity.this.finish (); finirà l'attività corrente.

Quando passi da un'attività all'altra continua a finire la precedente

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

Prima di tutto, questo approccio richiede un minimo di Api 16.

Dividerò questa soluzione in 3 parti per risolvere questo problema in modo più ampio.

1. Se si vuole uscire applicazione in un Activity utilizzare questo frammento di codice:

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

2. Se si desidera chiudere l'applicazione in una classe non Activity che ha accesso all'Activity, utilizzare questo frammento di codice:

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

3. Se si desidera chiudere l'applicazione in una classe non Activity e non è possibile accedere ad Attività come Service, si consiglia di utilizzare BroadcastReceiver. Puoi aggiungere questo approccio a tutte le tue attività nel tuo progetto.

Creare variabili di istanza LocalBroadcastManager e BroadcastReceiver. Puoi sostituire getPackageName () + ". Closeapp" se vuoi.

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

Aggiungili al metodo di attività onCreate ().

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

Inoltre, non dimenticare di chiamare il ricevitore di annullamento della registrazione nel metodo di attività onDestroy ()

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Per chiudere l'applicazione, è necessario inviare la trasmissione utilizzando LocalBroadcastManager che utilizzo nella mia classe PlayService che estende il servizio.

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

Puoi usare finishAndRemoveTask ()da API 21

public void finishAndRemoveTask ()

Termina tutte le attività in questa attività e la rimuove dall'elenco delle attività recenti.

Dipende dalla velocità con cui vuoi chiudere l'app.

Un modo sicuro per chiudere l'app è finishAffinity ();

Chiude l'app al termine dell'elaborazione di tutti i processi. Questo potrebbe richiedere del tempo. Se chiudi l'app in questo modo e la riavvii dopo poco tempo, è possibile che la tua nuova applicazione venga eseguita nello stesso processo. Con tutti i processi non finiti e gli oggetti singleton della vecchia applicazione.

Se vuoi essere sicuro, che la tua app sia chiusa completamente usa System.exit (0);

Questo chiuderà immediatamente la tua app. Ma è possibile che tu danneggi i file aperti dalla tua app o che una modifica alle preferenze condivise non finisca. Quindi usa questo attentamente.

Se si utilizza il watchdog in combinazione con un'attività di lunga durata, è possibile vedere le influenze dei diversi metodi.

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

Questo uccide la tua app dopo 2 secondi senza visualizzare una finestra di dialogo ANR o qualcosa del genere. Se si rimuove System.exit (0) , si esegue questo codice e si riavvia l'app dopo che è stata chiusa, si verificherà un comportamento strano, poiché il ciclo infinito è ancora in esecuzione.

Faresti meglio a usarti finish()se ci sei Activityo getActivity().finish()se sei nel Fragment.

Se vuoi uscire completamente dall'app, usa:

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

Modo semplice e semplice per uscire dall'applicazione

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

Vogliamo un codice robusto e semplice. Questa soluzione funziona su dispositivi vecchi e dispositivi più recenti.

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        getActivity().finishAffinity();
    } else{
        getActivity().finish();
        System.exit( 0 );
    }

Penso che quello che stai cercando sia questo

activity.moveTaskToBack(Boolean nonRoot);

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

Simile a @MobileMateo, ma in Kotlin

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    this.finishAffinity()
} else{
    this.finish()
    System.exit(0)
}

Non sono sicuro se questo è malvisto o no, ma è così che lo faccio ...

Passaggio 1: di solito ho una classe che contiene metodi e variabili a cui voglio accedere a livello globale. In questo esempio la chiamerò la classe "App". Crea una variabile di attività statica all'interno della classe per ogni attività della tua app. Quindi creare un metodo statico chiamato "close" che eseguirà il finish()metodo su ciascuna di quelle variabili di attività se NON sono null . Se hai un'attività principale / principale, chiudila per ultima:

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

Passaggio 2: in ciascuna delle attività, sovrascrivere i metodi onStart()e onDestroy(). In onStart(), imposta la variabile statica nella tua classe App uguale a " this". In onDestroy(), impostalo uguale a null. Ad esempio, nella classe "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;
}

Passaggio 3: quando desideri chiudere l'app, chiama semplicemente App.close()da qualsiasi luogo. Tutte le attività istanziate si chiuderanno! Poiché stai solo chiudendo le attività e non stai uccidendo l'app stessa (come nei tuoi esempi), Android è libero di prendere il controllo da lì e fare qualsiasi pulizia necessaria.

Ancora una volta, non so se questo sarebbe disapprovato per qualsiasi motivo. In tal caso, mi piacerebbe leggere i commenti sul perché è e su come può essere migliorato!

La chiusura di una domanda è disapprovata? . Passa attraverso questo link. Risponde alla tua domanda. Il sistema svolge il compito di uccidere un'applicazione.

Supponiamo di avere due attività da A a B. Naviga da A a B. Quando fai clic sul pulsante Indietro, la tua attività B viene visualizzata dal backstack e distrutta. L'attività precedente nell'attività di back stack A si concentra.

Dovresti lasciarlo al sistema per decidere quando uccidere l'applicazione.

vuoto pubblico finish()

Chiamalo quando la tua attività è terminata e dovrebbe essere chiusa.

Supponiamo di avere molte attività. puoi usare la barra delle azioni. Facendo clic sull'icona home naviagate su MainActivity dell'applicazione. In MainActivity fare clic sul pulsante Indietro per uscire dall'applicazione.

Per uscire dall'applicazione è possibile utilizzare quanto segue:

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

Anche per interrompere anche i servizi chiamare il seguente metodo:

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

Questo potrebbe essere molto tardi e anche secondo le linee guida non dovresti gestire il processo del ciclo di vita da solo (come l'OS fa per te). Un suggerimento potrebbe essere quello di registrare un ricevitore di trasmissione in tutte le tue attività con " finish()" nella loro onReceive() e ogni volta che desideri uscire puoi semplicemente passare un intento che indica che tutte le attività devono essere chiuse ..... Anche se assicurati di farlo " annulla la registrazione "del destinatario nei tuoi onDestroy()metodi.

Non è una buona decisione, perché è contro i principi di elaborazione delle applicazioni di Android. Android non uccide alcun processo a meno che non sia assolutamente inevitabile. Ciò consente alle app di avviarsi più rapidamente, poiché sono sempre conservate in memoria. Quindi hai bisogno di un motivo molto speciale per interrompere il processo di candidatura.

La soluzione corretta ed esatta per chiudere l'app al clic del pulsante sta usando il codice seguente:

// Evento premuto il pulsante Indietro

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

Se stai usando Kotlin, il modo corretto di uscire dall'app e un'alternativa System.exit()è un metodo integrato

exitProcess(0)

Vedere la documentazione di .

Il numero 0come parametro indica l'uscita prevista e non si è verificato alcun errore.

Questo ucciderà qualsiasi cosa;)

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

Prova questo

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

Il modo più semplice che ho trovato per uscire da un'applicazione da un'attività, senza interrompere la logica di Android e senza aggiungere altro codice nelle attività esistenti e passare extra è il seguente:

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

l' QuitApplicationActivityessere:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

La risposta di @Sivi chiude l'app. Ma al ritorno, se hai alcune attività secondarie, un'altra attività incompiuta potrebbe essere aperta. Ho aggiunto noHistory:truealle mie attività quindi l'app al ritorno inizia da MainActivity.

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

Solo per aggiungerne uno all'elenco di metodi brutali per terminare un'app:

Process.sendSignal(Process.myPid(), Process.SIGNAL_KILL);

puoi chiudere le tue app complete. così

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

funzionerà al 100%. Buona fortuna!

Basta usare finish () sul tasto Indietro premere onKeypressed ()