So beenden Sie die Android-Anwendung programmgesteuert

Ich habe einige Codes gefunden, um eine Android-Anwendung programmgesteuert zu beenden. Wenn Sie einen der folgenden Codes in onDestroy () aufrufen, wird die Anwendung dann vollständig beendet?

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

Ich möchte meine Anwendung nicht im Hintergrund ausführen, nachdem ich auf die Schaltfläche "Beenden" geklickt habe. Bitte schlagen Sie mir vor, kann ich einen dieser Codes verwenden, um meine App zu beenden? Wenn ja, welchen Code kann ich verwenden? Ist es eine gute Möglichkeit, die App in Android zu beenden?

Seit API 16 können Sie die Methode finishAffinity verwenden, die dem Schließen aller zugehörigen Aktivitäten durch ihren Namen und die Javadoc-Beschreibung ziemlich nahe zu kommen scheint:

this.finishAffinity ();

Beenden Sie diese Aktivität sowie alle Aktivitäten direkt darunter in der aktuellen Aufgabe, die dieselbe Affinität haben. Dies wird normalerweise verwendet, wenn eine Anwendung für eine andere Aufgabe gestartet werden kann (z. B. von einer ACTION_VIEW eines Inhaltstyps, den sie versteht) und der Benutzer die Aufwärtsnavigation verwendet hat, um von der aktuellen Aufgabe zu einer eigenen Aufgabe zu wechseln. Wenn der Benutzer in diesem Fall zu anderen Aktivitäten der zweiten Anwendung navigiert ist, sollten alle diese Aktivitäten im Rahmen des Aufgabenwechsels aus der ursprünglichen Aufgabe entfernt werden.

Beachten Sie, dass Sie mit diesem Finish keine Ergebnisse für die vorherige Aktivität liefern können. Wenn Sie dies versuchen, wird eine Ausnahme ausgelöst.

Seit API 21 können Sie einen sehr ähnlichen Befehl verwenden

finishAndRemoveTask ();

Beendet alle Aktivitäten in dieser Aufgabe und entfernt sie aus der Liste der letzten Aufgaben.

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

Dies ist der beste Weg, um Ihre App zu beenden. !!!

Die beste Lösung für mich.

finishAffinity();

System.exit(0);

Wenn Sie nur verwenden, finishAffinity();ohne dass System.exit(0);Ihre Anwendung beendet wird, der zugewiesene Speicher jedoch weiterhin von Ihrem Telefon verwendet wird, verwenden Sie beide. Wenn Sie eine App sauber und wirklich beenden möchten, verwenden Sie beide.

Dies ist die einfachste Methode und funktioniert überall. Beenden Sie die App wirklich. Sie können eine Menge Aktivitäten öffnen, die alle problemlos beenden.

Beispiel auf einen Button klicken

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

oder wenn Sie etwas Nettes wollen, zum Beispiel mit einem Warndialog mit 3 Tasten JA NEIN und ABBRECHEN

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

Denken Sie bitte genau darüber nach, ob Sie die Anwendung beenden müssen: Lassen Sie das Betriebssystem herausfinden, wo und wann die Ressourcen freigegeben werden sollen.

Andernfalls, wenn Sie absolut sicher sind, verwenden Sie

finish();

Als Reaktion auf den Kommentar von @dave appleton: Lesen Sie als erstes die große Frage / Antwort-Kombination @gabriel: Wird das Beenden einer Anwendung verpönt?

Unter der Annahme, dass wir das haben, hat die Frage hier immer noch eine Antwort: Der Code, den Sie benötigen, wenn Sie etwas mit dem Beenden tun, ist finish(). Natürlich können Sie mehr als eine Aktivität usw. usw. haben, aber das ist nicht der Punkt. Lassen Sie uns einige Anwendungsfälle ausführen

1. Sie möchten, dass der Benutzer alles aufgrund der Speichernutzung beendet und "nicht im Hintergrund ausgeführt wird? Zweifelhaft. Lassen Sie den Benutzer bestimmte Aktivitäten im Hintergrund stoppen, aber das Betriebssystem alle nicht benötigten Ressourcen beenden.
2. Sie möchten, dass ein Benutzer nicht zur vorherigen Aktivität Ihrer App wechselt? Konfigurieren Sie es entweder so, dass dies nicht der Fall ist, oder Sie benötigen eine zusätzliche Option. Wenn die back = vorherige Aktivität die meiste Zeit funktioniert, würde der Benutzer dann nicht einfach nach Hause drücken, wenn er etwas anderes tun möchte?
3. Wenn Sie eine Art Reset benötigen, können Sie herausfinden, ob / wie / usw. Ihre Anwendung beendet wurde. Wenn Ihre Aktivität wieder in den Fokus gerückt wird, können Sie Maßnahmen ergreifen und einen neuen Bildschirm anzeigen, anstatt neu zu starten, wo Sie sich befanden.

Am Ende tötet finish()natürlich nicht alles, aber es ist immer noch das Werkzeug, das Sie brauchen, denke ich. Wenn es einen Anwendungsfall für "Alle Aktivitäten töten" gibt, habe ich ihn noch nicht gefunden.

Ich denke, dass die Anwendung in einigen Fällen töten sollte. Zum Beispiel gibt es eine App, die erst nach dem Login verwendet werden kann. Die Anmeldeaktivität verfügt über zwei Schaltflächen: "Anmelden" und "Abbrechen". Wenn Sie auf die Schaltfläche "Abbrechen" klicken, bedeutet dies definitiv "App beenden". Niemand möchte, dass die App im Hintergrund lebt. Daher stimme ich zu, dass in einigen Fällen die App heruntergefahren werden muss.

Erstellen Sie ein ExitActivityund deklarieren Sie es im Manifest. Und fordern Sie ExitActivity.exit(context)zum Beenden der App auf.

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

}

In Android wird keine Anwendung beendet . SampleActivity.this.finish (); beendet die aktuelle Aktivität.

Wenn Sie von einer Aktivität zu einer anderen wechseln, beenden Sie die vorherige

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

Zuallererst erfordert dieser Ansatz mindestens Api 16.

Ich werde diese Lösung in drei Teile teilen, um dieses Problem weiter zu lösen.

1. Wenn Sie die Anwendung in einer Aktivität beenden möchten, verwenden Sie diesen Codeausschnitt:

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

2. Wenn Sie die Anwendung in einer Nicht-Aktivitätsklasse beenden möchten, die Zugriff auf Aktivität hat, verwenden Sie diesen Codeausschnitt:

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

3. Wenn Sie die Anwendung in einer Nicht-Aktivitätsklasse beenden möchten und nicht auf Aktivitäten wie Service zugreifen können, empfehle ich Ihnen, BroadcastReceiver zu verwenden. Sie können diesen Ansatz allen Ihren Aktivitäten in Ihrem Projekt hinzufügen.

Erstellen Sie die Instanzvariablen LocalBroadcastManager und BroadcastReceiver. Sie können getPackageName () + ". Closeapp" ersetzen, wenn Sie möchten.

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

Fügen Sie diese der onCreate () -Methode hinzu.

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

Vergessen Sie auch nicht, den Empfänger bei der onDestroy () - Aktivitätsmethode abzumelden

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Zum Beenden der Anwendung müssen Sie Broadcasts mit LocalBroadcastManager senden, den ich in meiner PlayService-Klasse verwende, die Service erweitert.

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

Sie können finishAndRemoveTask ()von API 21 verwenden

public void finishAndRemoveTask ()

Beendet alle Aktivitäten in dieser Aufgabe und entfernt sie aus der Liste der letzten Aufgaben.

Dies hängt davon ab, wie schnell Sie Ihre App schließen möchten.

Ein sicherer Weg, um Ihre App zu schließen, ist finishAffinity ();

Es schließt Ihre App, nachdem alle Prozesse die Verarbeitung abgeschlossen haben. Dies kann einige Zeit dauern. Wenn Sie Ihre App auf diese Weise schließen und nach kurzer Zeit neu starten, wird Ihre neue Anwendung möglicherweise im selben Prozess ausgeführt. Mit allen nicht abgeschlossenen Prozessen und Singleton-Objekten der alten Anwendung.

Wenn Sie sicher sein möchten, dass Ihre App vollständig geschlossen ist, verwenden Sie System.exit (0).

Dadurch wird Ihre App sofort geschlossen. Es ist jedoch möglich, dass Sie Dateien beschädigen, die Ihre App geöffnet hat, oder dass eine Bearbeitung der freigegebenen Einstellungen nicht abgeschlossen wird. Gehen Sie also vorsichtig damit um.

Wenn Sie Watchdog in Kombination mit einer lang laufenden Aufgabe verwenden, können Sie die Einflüsse der verschiedenen Methoden erkennen.

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

Dadurch wird Ihre App nach 2 Sekunden beendet, ohne dass ein ANR-Dialogfeld oder ähnliches angezeigt wird. Wenn Sie System.exit (0) entfernen , diesen Code ausführen und die App nach dem Schließen neu starten, tritt ein seltsames Verhalten auf, da die Endlosschleife noch ausgeführt wird.

Sie sollten besser verwenden, finish()wenn Sie in sind Activity, oder getActivity().finish()wenn Sie in der sind Fragment.

Wenn Sie die App vollständig beenden möchten, verwenden Sie:

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

Einfache und einfache Möglichkeit, die Anwendung zu beenden

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

Ich denke, was Sie suchen, ist dies

activity.moveTaskToBack(Boolean nonRoot);

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

Wir wollen Code, der robust und einfach ist. Diese Lösung funktioniert auf alten und neueren Geräten.

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

Ähnlich wie @MobileMateo, aber in Kotlin

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

Ich bin mir nicht sicher, ob dies verpönt ist oder nicht, aber so mache ich es ...

Schritt 1 - Normalerweise habe ich eine Klasse, die Methoden und Variablen enthält, auf die ich global zugreifen möchte. In diesem Beispiel werde ich es die "App" -Klasse nennen. Erstellen Sie für jede Aktivität Ihrer App eine statische Aktivitätsvariable innerhalb der Klasse. Erstellen Sie dann eine statische Methode namens "close", die die finish()Methode für jede dieser Aktivitätsvariablen ausführt, wenn sie NICHT null sind . Wenn Sie eine Haupt- / Elternaktivität haben, schließen Sie diese zuletzt:

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

Schritt 2 - Überschreiben Sie in jeder Ihrer Aktivitäten die Methoden onStart()und onDestroy(). In onStart(), setzen die statische Variable in Ihrer App - Klasse „gleich this“. In onDestroy()setzen Sie es gleich null. Zum Beispiel in der Klasse "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;
}

Schritt 3 - Wenn Sie Ihre App schließen möchten, rufen Sie einfach anApp.close() von überall an. Alle instanziierten Aktivitäten werden geschlossen! Da Sie nur Aktivitäten schließen und die App selbst nicht beenden (wie in Ihren Beispielen), kann Android von dort aus übernehmen und alle erforderlichen Bereinigungen vornehmen.

Auch hier weiß ich nicht, ob dies aus irgendeinem Grund verpönt wäre. Wenn ja, würde ich gerne Kommentare darüber lesen, warum es so ist und wie es verbessert werden kann!

Ist das Beenden einer Bewerbung verpönt? . Gehen Sie über diesen Link. Es beantwortet Ihre Frage. Das System erledigt das Beenden einer Anwendung.

Angenommen, Sie haben zwei Aktivitäten A und B. Sie navigieren von A nach B. Wenn Sie auf die Schaltfläche Zurück klicken, wird Ihre Aktivität B aus dem Backstack entfernt und zerstört. Vorherige Aktivität in Backstack-Aktivität A steht im Mittelpunkt.

Sie sollten es dem System überlassen, zu entscheiden, wann die Anwendung beendet werden soll.

öffentliche Leere finish()

Rufen Sie dies an, wenn Ihre Aktivität abgeschlossen ist und geschlossen werden sollte.

Angenommen, Sie haben viele Aktivitäten. Sie können die Aktionsleiste verwenden. Klicken Sie auf das Startsymbol, um zur Hauptaktivität Ihrer Anwendung zu navigieren. Klicken Sie in MainActivity auf die Schaltfläche Zurück, um die Anwendung zu beenden.

Um Ihre Anwendung zu beenden, können Sie Folgendes verwenden:

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

Um auch die Dienste zu stoppen, rufen Sie die folgende Methode auf:

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

Dies kann sehr spät sein und auch gemäß den Richtlinien sollten Sie den Lebenszyklusprozess nicht selbst erledigen (wie das Betriebssystem dies für Sie erledigt). Ein Vorschlag wäre, dass Sie einen Rundfunkempfänger in all Ihren Aktivitäten mit " finish()" in deren onReceive() & registrieren, und wann immer Sie beenden möchten, können Sie einfach eine Absicht übergeben, die angibt, dass alle Aktivitäten beendet werden müssen ..... Obwohl Sie dies sicherstellen müssen " Heben Sie die Registrierung des Empfängers in Ihren onDestroy()Methoden auf.

Es ist keine gute Entscheidung, da sie gegen die Anwendungsverarbeitungsprinzipien von Android verstößt. Android beendet keinen Prozess, es sei denn, dies ist absolut unvermeidlich. Dies hilft Apps, schneller zu starten, da sie immer im Speicher bleiben. Sie benötigen also einen ganz besonderen Grund, um den Prozess Ihrer Bewerbung abzubrechen.

Die richtige und genaue Lösung, um die App beim Klicken auf die Schaltfläche zu beenden ist der folgende Code:

// On Button Zurück gedrücktes Ereignis

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

Wenn Sie Kotlin verwenden, System.exit()ist eine integrierte Methode der richtige Weg, um die App zu beenden

exitProcess(0)

Siehe die Dokumentation .

Die Zahl 0als Parameter bedeutet, dass der Exit beabsichtigt ist und kein Fehler aufgetreten ist.

Dies wird alles töten;)

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

Versuche dies

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

Der einfachste Weg, eine Anwendung aus einer Aktivität zu beenden, ohne die Logik von Android zu brechen und ohne mehr Code in vorhandene Aktivitäten einzufügen und Extras zu übergeben, ist der folgende:

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

das QuitApplicationActivityWesen:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

Die Antwort von @Sivi schließt die App. Wenn Sie jedoch bei der Rückkehr einige untergeordnete Aktivitäten haben, wird möglicherweise eine andere unvollendete Aktivität geöffnet. Ich noHistory:truehabe meine Aktivitäten erweitert, damit die App bei der Rückkehr von MainActivity startet.

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

Nur um eine zur Liste der brutalen Methoden zum Beenden einer App hinzuzufügen:

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

Sie können Ihre vollständigen Apps beenden. somit

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

es wird 100% funktionieren. Viel Glück!

Verwenden Sie einfach finish () für die Zurück-Taste. Drücken Sie onKeypressed ()