Come chiudere l'applicazione Android?

Voglio chiudere la mia applicazione, in modo che non venga più eseguita in background.

Come farlo? Questa buona pratica è su piattaforma Android?

Se faccio affidamento sul pulsante "indietro", si chiude l'app, ma rimane in background. Esiste persino un'applicazione chiamata "TaskKiller" solo per uccidere quelle app in background.

Android ha un meccanismo in atto per chiudere un'applicazione in modo sicuro secondo la sua documentazione. Nell'ultima attività che è uscita (di solito l'attività principale che è venuta per la prima volta all'avvio dell'applicazione) basta posizionare un paio di righe nel metodo onDestroy (). La chiamata a System.runFinalizersOnExit (true) garantisce che tutti gli oggetti vengano finalizzati e che la spazzatura venga raccolta alla chiusura dell'applicazione. Puoi anche uccidere rapidamente un'applicazione tramite android.os.Process.killProcess (android.os.Process.myPid ()) se preferisci. Il modo migliore per farlo è inserire un metodo come il seguente in una classe di supporto e quindi chiamarlo ogni volta che l'app deve essere uccisa. Ad esempio nel metodo di distruzione dell'attività radice (supponendo che l'app non uccida mai questa attività):

Inoltre Android non notificherà un'applicazione dell'evento del tasto HOME , quindi non è possibile chiudere l'applicazione quando si preme il tasto HOME . Android si riserva l' evento chiave HOME in modo che uno sviluppatore non possa impedire agli utenti di abbandonare la propria applicazione. Tuttavia è possibile determinare con il tasto HOME premuto premendo un flag su true in una classe helper che presuppone che il tasto HOME sia stato premuto, quindi cambiando il flag in false quando si verifica un evento che mostra che il tasto HOME non è stato premuto e quindi controllando di vedere il tasto HOME premuto nel metodo onStop () dell'attività.

Non dimenticare di gestire il tasto HOME per qualsiasi menu e nelle attività avviate dai menu. Lo stesso vale per il tasto CERCA . Di seguito sono riportate alcune classi di esempio da illustrare:

Ecco un esempio di un'attività di root che uccide l'applicazione quando viene distrutta:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

public class HomeKey extends CustomActivity {

    public void onDestroy() {
        super.onDestroy();

        /*
         * Kill application when the root activity is killed.
         */
        UIHelper.killApp(true);
    }

}

Ecco un'attività astratta che può essere estesa per gestire il tasto HOME per tutte le attività che lo estendono:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

import android.app.Activity;
import android.view.Menu;
import android.view.MenuInflater;

/**
 * Activity that includes custom behavior shared across the application. For
 * example, bringing up a menu with the settings icon when the menu button is
 * pressed by the user and then starting the settings activity when the user
 * clicks on the settings icon.
 */
public abstract class CustomActivity extends Activity {
    public void onStart() {
        super.onStart();

        /*
         * Check if the app was just launched. If the app was just launched then
         * assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs. Otherwise the user or the app
         * navigated to this activity so the HOME key was not pressed.
         */

        UIHelper.checkJustLaunced();
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed. Otherwise the user or the app is navigating
         * away from this activity so assume that the HOME key will be pressed
         * next unless a navigation event by the user or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.settings_menu, menu);

        /*
         * Assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs.
         */
        UIHelper.homeKeyPressed = true;

        return true;
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }
}

Ecco un esempio di una schermata del menu che gestisce il tasto HOME :

/**
 * @author Danny Remington - MacroSolve
 */

package android.example;

import android.os.Bundle;
import android.preference.PreferenceActivity;

/**
 * PreferenceActivity for the settings screen.
 * 
 * @see PreferenceActivity
 * 
 */
public class SettingsScreen extends PreferenceActivity {
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.layout.settings_screen);
    }

    public void onStart() {
        super.onStart();

        /*
         * This can only invoked by the user or the app starting the activity by
         * navigating to the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed either safely or quickly. Otherwise the user
         * or the app is navigating away from the activity so assume that the
         * HOME key will be pressed next unless a navigation event by the user
         * or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }

}

Ecco un esempio di una classe di supporto che gestisce la chiave HOME in tutta l'app:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 *
 */

/**
 * Helper class to help handling of UI.
 */
public class UIHelper {
    public static boolean homeKeyPressed;
    private static boolean justLaunched = true;

    /**
     * Check if the app was just launched. If the app was just launched then
     * assume that the HOME key will be pressed next unless a navigation event
     * by the user or the app occurs. Otherwise the user or the app navigated to
     * the activity so the HOME key was not pressed.
     */
    public static void checkJustLaunced() {
        if (justLaunched) {
            homeKeyPressed = true;
            justLaunched = false;
        } else {
            homeKeyPressed = false;
        }
    }

    /**
     * Check if the HOME key was pressed. If the HOME key was pressed then the
     * app will be killed either safely or quickly. Otherwise the user or the
     * app is navigating away from the activity so assume that the HOME key will
     * be pressed next unless a navigation event by the user or the app occurs.
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly when the HOME key is pressed.
     * 
     * @see {@link UIHelper.killApp}
     */
    public static void checkHomeKeyPressed(boolean killSafely) {
        if (homeKeyPressed) {
            killApp(true);
        } else {
            homeKeyPressed = true;
        }
    }

    /**
     * Kill the app either safely or quickly. The app is killed safely by
     * killing the virtual machine that the app runs in after finalizing all
     * {@link Object}s created by the app. The app is killed quickly by abruptly
     * killing the process that the virtual machine that runs the app runs in
     * without finalizing all {@link Object}s created by the app. Whether the
     * app is killed safely or quickly the app will be completely created as a
     * new app in a new virtual machine running in a new process if the user
     * starts the app again.
     * 
     * <P>
     * <B>NOTE:</B> The app will not be killed until all of its threads have
     * closed if it is killed safely.
     * </P>
     * 
     * <P>
     * <B>NOTE:</B> All threads running under the process will be abruptly
     * killed when the app is killed quickly. This can lead to various issues
     * related to threading. For example, if one of those threads was making
     * multiple related changes to the database, then it may have committed some
     * of those changes but not all of those changes when it was abruptly
     * killed.
     * </P>
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly. If true then the app will be killed
     *            safely. Otherwise it will be killed quickly.
     */
    public static void killApp(boolean killSafely) {
        if (killSafely) {
            /*
             * Notify the system to finalize and collect all objects of the app
             * on exit so that the virtual machine running the app can be killed
             * by the system without causing issues. NOTE: If this is set to
             * true then the virtual machine will not be killed until all of its
             * threads have closed.
             */
            System.runFinalizersOnExit(true);

            /*
             * Force the system to close the app down completely instead of
             * retaining it in the background. The virtual machine that runs the
             * app will be killed. The app will be completely created as a new
             * app in a new virtual machine running in a new process if the user
             * starts the app again.
             */
            System.exit(0);
        } else {
            /*
             * Alternatively the process that runs the virtual machine could be
             * abruptly killed. This is the quickest way to remove the app from
             * the device but it could cause problems since resources will not
             * be finalized first. For example, all threads running under the
             * process will be abruptly killed when the process is abruptly
             * killed. If one of those threads was making multiple related
             * changes to the database, then it may have committed some of those
             * changes but not all of those changes when it was abruptly killed.
             */
            android.os.Process.killProcess(android.os.Process.myPid());
        }

    }
}

SÌ! Puoi sicuramente chiudere la tua applicazione in modo che non sia più in esecuzione in background. Come altri hanno commentato, finish()il modo consigliato da Google non significa che il tuo programma sia chiuso.

System.exit(0);

Proprio lì chiuderai la tua applicazione lasciando nulla in esecuzione in background.Tuttavia, usalo con saggezza e non lasciare i file aperti, gli handle di database aperti, ecc. Queste cose verrebbero normalmente ripulite tramite il finish()comando.

Personalmente odio quando scelgo Exit in un'applicazione e non esce.

Questo è il modo in cui l'ho fatto:

Ho appena messo

Intent intent = new Intent(Main.this, SOMECLASSNAME.class);
Main.this.startActivityForResult(intent, 0);

all'interno del metodo che apre un'attività, quindi all'interno del metodo di SOMECLASSNAME progettato per chiudere l'app che ho inserito:

setResult(0);
finish();

E ho inserito quanto segue nella mia classe principale:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if(resultCode == 0) {
        finish();
    }
}

Solo per rispondere alla mia domanda ora dopo così tanto tempo (dal momento che CommonsWare ha commentato la risposta più popolare dicendo che NON dovremmo farlo):

Quando voglio uscire dall'app:

1. Inizio la mia prima attività (schermata iniziale o qualsiasi altra attività sia attualmente nella parte inferiore dello stack di attività) con FLAG_ACTIVITY_CLEAR_TOP(che chiuderà tutte le altre attività avviate dopo di essa, il che significa - tutte). Basta fare in modo che questa attività sia nello stack di attività (non finirla per qualche motivo in anticipo).
2. Invito finish()questa attività

Questo è tutto, funziona abbastanza bene per me.

Basta scrivere questo codice sul pulsante ESCI clic.

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("LOGOUT", true);
startActivity(intent);

E nel metodo onCreate () di MainActivity.class scrivi sotto il codice come prima riga,

if (getIntent().getBooleanExtra("LOGOUT", false))
{
    finish();
}

Non è possibile utilizzare le API del framework. È a discrezione del sistema operativo (Android) decidere quando rimuovere o conservare un processo in memoria. Questo per motivi di efficienza: se l'utente decide di riavviare l'app, allora è già lì senza che debba essere caricato in memoria.

Quindi no, non è solo scoraggiato , è impossibile farlo.

Per uscire dalle modalità app:

Modo 1:

chiama finish();e ignora onDestroy();. Inserisci il seguente codice in onDestroy():

System.runFinalizersOnExit(true)

o

android.os.Process.killProcess(android.os.Process.myPid());

Modo 2:

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

Modo 3:

Quit();

protected void Quit() {
    super.finish();
}

Modo 4:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("EXIT", true);
startActivity(intent);

if (getIntent().getBooleanExtra("EXIT", false)) {
     finish();
}

Modo 5:

A volte la chiamata finish()esce solo dall'attività corrente, non dall'intera applicazione. Tuttavia, esiste una soluzione alternativa per questo. Ogni volta che si avvia un activity, avviarlo usando startActivityForResult(). Quando vuoi chiudere l'intera app, puoi fare qualcosa del tipo:

setResult(RESULT_CLOSE_ALL);
finish();

Quindi definire il onActivityResult(...)callback di ogni attività, quindi quando activityritorna con il RESULT_CLOSE_ALLvalore, chiama anche finish():

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(resultCode){
        case RESULT_CLOSE_ALL:{
            setResult(RESULT_CLOSE_ALL);
            finish();
        }
    }
    super.onActivityResult(requestCode, resultCode, data);
}

Ecco come Windows Mobile ha funzionato per ... beh ... sempre! Ecco cosa Microsoft ha da dire sull'argomento:

http://blogs.msdn.com/windowsmobile/archive/2006/10/05/The-Emperor-Has-No-Close.aspx (è triste che mi sia ricordato il titolo del post sul blog dal 2006? Ho trovato l'articolo su Google cercando "l'imperatore non ha vicino" lol)

In breve:

Se il sistema ha bisogno di più memoria mentre l'app è in background, chiuderà l'app. Ma se il sistema non ha bisogno di più memoria, l'app rimarrà nella RAM e sarà pronta per tornare rapidamente la prossima volta che l'utente ne avrà bisogno.

Molti commenti in questa domanda a O'Reilly suggeriscono che Android si comporta allo stesso modo, chiudendo le applicazioni che non sono state utilizzate per un po 'solo quando Android ha bisogno della memoria che stanno utilizzando.

Dal momento che questa è una funzionalità standard, quindi cambiare il comportamento per chiudere forzatamente significherebbe cambiare l'esperienza dell'utente. Molti utenti sarebbero abituati al delicato licenziamento delle loro app Android, quindi quando ne respingono uno con l'intenzione di tornarci dopo aver eseguito alcune altre attività, potrebbero essere piuttosto frustrati dal fatto che lo stato dell'applicazione venga ripristinato o che impieghi più tempo aprire. Seguirò il comportamento standard perché è quello che ci si aspetta.

Chiamando il finish()metodo su un'attività ha l'effetto desiderato su quella attività corrente.

nessuna delle risposte precedenti funziona bene sulla mia app

ecco il mio codice di lavoro

sul pulsante di uscita:

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
ComponentName cn = intent.getComponent();
Intent mainIntent = IntentCompat.makeRestartActivityTask(cn);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
mainIntent.putExtra("close", true);
startActivity(mainIntent);
finish();

quel codice è quello di chiudere qualsiasi altra attività e portare MainActivity in cima ora su MainActivity:

if( getIntent().getBooleanExtra("close", false)){
    finish();
}

Metti una finish();dichiarazione come di seguito:

myIntent.putExtra("key1", editText2.getText().toString());

finish();

LoginActivity.this.startActivity(myIntent);

In ogni attività.

@Override
    protected void onPause() {

        super.onPause();

        System.exit(0);

    }

Copia il codice seguente e incolla il file AndroidManifest.xml in Primo tag attività.

<activity                        
            android:name="com.SplashActivity"
            android:clearTaskOnLaunch="true" 
            android:launchMode="singleTask"
            android:excludeFromRecents="true">              
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER"
                />
            </intent-filter>
        </activity>     

Aggiungi anche questo codice di seguito in tutto in Tag attività nel file AndroidManifest.xml

 android:finishOnTaskLaunch="true"

Non possibile con 2.3. Cerco molte cose e ho provato molte app. La soluzione migliore è installare sia (go taskmanager) che (riavvio veloce). Quando li usi insieme funzionerà e libererà la memoria. Un'altra opzione è l'aggiornamento a Android Ice Cream Sandwich 4.0.4 che consente il controllo (chiusura) delle app.

volevo tornare alla schermata principale del mio dispositivo Android, quindi ho semplicemente usato:

moveTaskToBack(true);

L'uso di finishAffinity()può essere una buona opzione se desideri chiudere tutte le attività dell'app. Secondo i documenti Android-

Finish this activity as well as all activities immediately below it in the current task that have the same affinity.

public class CloseAppActivity extends AppCompatActivity
{
    public static final void closeApp(Activity activity)
    {
        Intent intent = new Intent(activity, CloseAppActivity.class);
        intent.addCategory(Intent.CATEGORY_HOME);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                IntentCompat.FLAG_ACTIVITY_CLEAR_TASK);
        activity.startActivity(intent);
    }

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

e in manifest:

<activity
     android:name=".presenter.activity.CloseAppActivity"
     android:noHistory="true"
     android:clearTaskOnLaunch="true"/>

Quindi è possibile chiamare CloseAppActivity.closeApp(fromActivity)e l'applicazione verrà chiusa.

Scrivi semplicemente il seguente codice su onBackPressed:

@Override
public void onBackPressed() {
    // super.onBackPressed();

    //Creating an alert dialog to logout
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setMessage("Do you want to Exit?");
    alertDialogBuilder.setPositiveButton("Yes",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {
                    Intent intent = new Intent(Intent.ACTION_MAIN);
                    intent.addCategory(Intent.CATEGORY_HOME);
                    startActivity(intent);
                }
            });

    alertDialogBuilder.setNegativeButton("No",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {

                }
            });

    //Showing the alert dialog
    AlertDialog alertDialog = alertDialogBuilder.create();
    alertDialog.show();
}

chiamando finish (); nel pulsante OnClick o nel menu

case R.id.menu_settings:

      finish();
     return true;

Penso che chiuderà la tua attività e tutte le attività secondarie ad essa correlate.

public boolean onOptionsItemSelected(MenuItem item) {

        int id = item.getItemId();]
        if (id == R.id.Exit) {
            this.finishAffinity();
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

Il modo migliore e più breve per utilizzare la tabella System.exit.

System.exit(0);

La VM interrompe l'ulteriore esecuzione e il programma verrà chiuso.

Usa " this.FinishAndRemoveTask();" - chiude correttamente l'applicazione