Wie schließe ich die Android-Anwendung?

Ich möchte meine Anwendung schließen, damit sie nicht mehr im Hintergrund ausgeführt wird.

Wie geht das? Ist dies eine gute Praxis auf der Android-Plattform?

Wenn ich mich auf die Schaltfläche "Zurück" verlasse, wird die App geschlossen, bleibt jedoch im Hintergrund. Es gibt sogar eine Anwendung namens "TaskKiller", um diese Apps im Hintergrund zu beenden.

Android verfügt über einen Mechanismus zum sicheren Schließen einer Anwendung gemäß der Dokumentation. In der letzten Aktivität, die beendet wird (normalerweise die Hauptaktivität, die beim Start der Anwendung zum ersten Mal ausgeführt wurde), setzen Sie einfach ein paar Zeilen in die Methode onDestroy (). Der Aufruf von System.runFinalizersOnExit (true) stellt sicher, dass alle Objekte beim Beenden der Anwendung finalisiert und Müll gesammelt werden. Sie können eine Anwendung auch schnell über android.os.Process.killProcess (android.os.Process.myPid ()) beenden, wenn Sie dies bevorzugen. Der beste Weg, dies zu tun, besteht darin, eine Methode wie die folgende in eine Hilfsklasse einzufügen und sie dann aufzurufen, wenn die App beendet werden muss. Zum Beispiel in der Zerstörungsmethode der Root-Aktivität (vorausgesetzt, die App beendet diese Aktivität niemals):

Außerdem benachrichtigt Android eine Anwendung nicht über das HOME- Tastenereignis, sodass Sie die Anwendung nicht schließen können, wenn die HOME- Taste gedrückt wird. Android behält sich das HOME- Schlüsselereignis für sich vor, sodass ein Entwickler Benutzer nicht daran hindern kann, ihre Anwendung zu verlassen. Sie können jedoch mit der Bestimmung HOME - Taste durch Setzen eines Flags auf true in einer Hilfsklasse gedrückt wird, der, dass die übernimmt HOME - Taste gedrückt wurde, dann wird das Flag auf false zu ändern , wenn ein Ereignis , das zeigt , die auftritt HOME - Taste nicht gedrückt wurde und dann Überprüfen, ob die HOME- Taste in der onStop () -Methode der Aktivität gedrückt wurde .

Vergessen Sie nicht, die HOME- Taste für alle Menüs und für die Aktivitäten zu verwenden, die von den Menüs gestartet werden. Gleiches gilt für den SEARCH- Schlüssel. Nachfolgend einige Beispielklassen zur Veranschaulichung:

Hier ist ein Beispiel für eine Root-Aktivität, die die Anwendung beendet, wenn sie zerstört wird:

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

}

Hier ist eine abstrakte Aktivität, die erweitert werden kann, um den HOME- Schlüssel für alle Aktivitäten zu handhaben , die ihn erweitern:

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

Hier ist ein Beispiel für einen Menübildschirm, der die HOME- Taste behandelt:

/**
 * @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;
    }

}

Hier ist ein Beispiel für eine Hilfsklasse, die den HOME- Schlüssel in der gesamten App verarbeitet:

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

    }
}

JA! Sie können Ihre Anwendung mit Sicherheit schließen, damit sie nicht mehr im Hintergrund ausgeführt wird. Wie andere kommentiert haben, finish()ist der von Google empfohlene Weg, der nicht wirklich bedeutet, dass Ihr Programm geschlossen ist.

System.exit(0);

Mit diesem finish()Befehl wird Ihre Anwendung geschlossen, sodass nichts im Hintergrund ausgeführt wird. Verwenden Sie dies jedoch mit Bedacht und lassen Sie keine Dateien offen, Datenbankhandles offen usw. Diese Dinge werden normalerweise über den Befehl bereinigt .

Ich persönlich hasse es, wenn ich in einer Anwendung Beenden wähle und es nicht wirklich beendet wird.

So habe ich es gemacht:

Ich habe es gerade gesagt

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

Innerhalb der Methode, die eine Aktivität öffnet, und innerhalb der Methode von SOMECLASSNAME, mit der die von mir gesetzte App geschlossen werden soll:

setResult(0);
finish();

Und ich habe folgendes in meine Hauptklasse aufgenommen:

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

Nur um meine eigene Frage jetzt nach so langer Zeit zu beantworten (da CommonsWare die beliebteste Antwort kommentierte und sagte, wir sollten dies NICHT tun):

Wenn ich die App beenden möchte:

1. Ich beginne meine erste Aktivität (entweder Begrüßungsbildschirm oder eine FLAG_ACTIVITY_CLEAR_TOPandere Aktivität, die sich derzeit am unteren Rand des Aktivitätsstapels befindet) mit (wodurch alle anderen danach gestarteten Aktivitäten beendet werden, dh alle). Stellen Sie einfach sicher, dass diese Aktivität im Aktivitätsstapel enthalten ist (beenden Sie sie aus irgendeinem Grund nicht im Voraus).
2. Ich rufe finish()zu dieser Aktivität auf

Das ist es, funktioniert ganz gut für mich.

Schreiben Sie einfach diesen Code auf Ihre Schaltfläche EXIT-Klick.

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

Und in der onCreate () -Methode Ihrer MainActivity.class schreiben Sie den folgenden Code als erste Zeile:

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

Die Verwendung der Framework-APIs ist nicht möglich. Es liegt im Ermessen des Betriebssystems (Android), zu entscheiden, wann ein Prozess entfernt werden soll oder im Speicher verbleibt. Dies ist aus Effizienzgründen so: Wenn der Benutzer beschließt, die App neu zu starten, ist sie bereits vorhanden, ohne dass sie in den Speicher geladen werden muss.

Also nein, es ist nicht nur entmutigt , es ist unmöglich , dies zu tun.

Zum Beenden von App-Möglichkeiten:

Weg 1:

anrufen finish();und überschreiben onDestroy();. Geben Sie den folgenden Code ein onDestroy():

System.runFinalizersOnExit(true)

oder

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

Weg 2:

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

Weg 3:

Quit();

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

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

Weg 5:

Manchmal wird beim Aufrufen finish()nur die aktuelle Aktivität beendet, nicht die gesamte Anwendung. Hierfür gibt es jedoch eine Problemumgehung. Jedes Mal, wenn Sie ein starten activity, starten Sie es mit startActivityForResult(). Wenn Sie die gesamte App schließen möchten, können Sie Folgendes tun:

setResult(RESULT_CLOSE_ALL);
finish();

Definieren Sie dann den onActivityResult(...)Rückruf jeder Aktivität, sodass bei einer activityRückgabe mit dem RESULT_CLOSE_ALLWert auch Folgendes aufgerufen wird 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);
}

So hat Windows Mobile für ... nun ... jemals funktioniert! Microsoft hat dazu Folgendes zu sagen:

http://blogs.msdn.com/windowsmobile/archive/2006/10/05/The-Emperor-Has-No-Close.aspx (ist es traurig, dass ich mich bis 2006 an den Titel des Blogposts erinnert habe? Ich habe den Artikel bei Google gefunden, indem ich nach "Der Kaiser hat keine Nähe" gesucht habe. Lol)

Zusamenfassend:

Wenn das System mehr Speicher benötigt, während sich die App im Hintergrund befindet, wird die App geschlossen. Wenn das System jedoch nicht mehr Speicher benötigt, bleibt die App im RAM und ist bereit, beim nächsten Mal, wenn der Benutzer sie benötigt, schnell zurückzukehren.

Viele Kommentare in dieser Frage bei O'Reilly deuten darauf hin, dass sich Android ähnlich verhält und Anwendungen schließt, die eine Weile nicht mehr verwendet wurden, nur wenn Android den von ihnen verwendeten Speicher benötigt.

Da dies eine Standardfunktion ist, würde eine Änderung des Verhaltens zum erzwungenen Schließen die Benutzererfahrung verändern. Viele Benutzer sind es gewohnt, ihre Android-Apps sanft zu schließen. Wenn sie also eine App mit der Absicht schließen, nach der Ausführung einiger anderer Aufgaben zu ihr zurückzukehren, sind sie möglicherweise eher frustriert darüber, dass der Status der Anwendung zurückgesetzt wird oder länger dauert öffnen. Ich würde mich an das Standardverhalten halten, weil es das ist, was erwartet wird.

Das Aufrufen der finish()Methode für eine Aktivität hat den gewünschten Effekt auf diese aktuelle Aktivität.

Keine der oben genannten Antworten funktioniert gut in meiner App

Hier ist mein Arbeitscode

auf Ihrem Exit-Button:

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

Dieser Code dient dazu, alle anderen Aktivitäten zu schließen und MainActivity jetzt auf Ihrer MainActivity an die Spitze zu bringen:

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

Geben Sie eine finish();Erklärung wie folgt ab:

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

finish();

LoginActivity.this.startActivity(myIntent);

In jeder Aktivität.

@Override
    protected void onPause() {

        super.onPause();

        System.exit(0);

    }

Kopieren Sie den folgenden Code und fügen Sie die Datei AndroidManifest.xml unter First Activity Tag ein.

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

Fügen Sie auch den folgenden Code in allen unter Activity Tag in der Datei AndroidManifest.xml hinzu

 android:finishOnTaskLaunch="true"

Nicht möglich mit 2.3. Ich habe viel gesucht und viele Apps ausprobiert. Die beste Lösung besteht darin, sowohl (go taskmanager) als auch (schneller Neustart) zu installieren. Wenn Sie sie zusammen verwenden, funktioniert es und gibt den Speicher frei. Eine weitere Option ist das Upgrade auf Android Ice Cream Sandwich 4.0.4, mit dem Apps gesteuert (geschlossen) werden können.

Ich wollte zum Startbildschirm meines Android-Geräts zurückkehren, also benutzte ich einfach:

moveTaskToBack(true);

Die Verwendung von finishAffinity()kann eine gute Option sein, wenn Sie alle Aktivitäten der App schließen möchten. Laut Android Docs-

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

und im Manifest:

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

Dann können Sie anrufen CloseAppActivity.closeApp(fromActivity)und die Bewerbung wird geschlossen.

Schreiben Sie einfach den folgenden Code in 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();
}

durch Aufrufen von finish (); in der OnClick-Taste oder im Menü

case R.id.menu_settings:

      finish();
     return true;

Ich denke, es wird Ihre Aktivität und alle damit verbundenen Unteraktivitäten schließen.

public boolean onOptionsItemSelected(MenuItem item) {

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

        return super.onOptionsItemSelected(item);
    }

Der beste und kürzeste Weg, um die Tabelle System.exit zu verwenden.

System.exit(0);

Die VM stoppt die weitere Ausführung und das Programm wird beendet.

Verwenden Sie " this.FinishAndRemoveTask();" - die Anwendung wird ordnungsgemäß geschlossen