Schließen Sie die Anwendung und starten Sie den Startbildschirm unter Android

Ich habe zwei verschiedene Aktivitäten. Der erste startet den zweiten. In der zweiten Aktivität rufe ich System.exit(0)auf, um das Schließen der Anwendung zu erzwingen. Die erste Aktivität wird jedoch automatisch angezeigt, anstatt dass die Anwendung zum Startbildschirm zurückkehrt. Wie kann ich dies vermeiden und die Anwendung dazu bringen, zum Startbildschirm zurückzukehren?

Sie sollten wirklich darüber nachdenken, die Anwendung nicht zu beenden. So funktionieren Android-Apps normalerweise nicht.

Kurze Antwort: Rufen moveTaskToBack(true)Sie anActivity statt System.exit(). Dadurch wird Ihre Anwendung ausgeblendet, bis der Benutzer sie erneut verwenden möchte.

Die längere Antwort beginnt mit einer anderen Frage: Warum möchten Sie Ihre Anwendung beenden?

Das Android-Betriebssystem übernimmt die Speicherverwaltung und -prozesse usw. Mein Rat ist also, dass Android sich nur darum kümmert. Wenn der Benutzer Ihre Anwendung verlassen möchte, kann er die Home-Taste drücken, und Ihre Anwendung wird effektiv ausgeblendet. Wenn das Telefon später mehr Speicher benötigt, beendet das Betriebssystem Ihre Anwendung.

Solange Sie angemessen auf Lebenszyklusereignisse reagieren , müssen sich weder Sie noch der Benutzer darum kümmern, ob Ihre Anwendung noch ausgeführt wird oder nicht.

Wenn Sie also Ihren Anwendungsaufruf ausblenden moveTaskToBack()und Android entscheiden lassen möchten , wann er beendet werden soll.

Der einfachste Weg, dies zu erreichen, ist unten angegeben (ohne die native Speicherverwaltung von Android zu beeinträchtigen. Es ist kein Prozessabbruch erforderlich).

1. Starten Sie eine Aktivität mit dieser Absicht:

   Intent intent = new Intent(this, FinActivity.class);
   intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
   startActivity(intent);
   finish();
   

2. FinActivity.classRufen Sie in der Zielaktivität finish () in auf onCreate.

Erklärte Schritte:

1. Sie erstellen eine Absicht, die alle anderen Aktivitäten löscht (FLAG_ACTIVITY_CLEAR_TOP)und die aktuelle Aktivität löscht .

2. Die Aktivität zerstört sich selbst. Eine Alternative besteht darin, dass Sie in finActivity einen Begrüßungsbildschirm erstellen können. Dies ist optional.

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 onDestroy () -Methode. Der Aufruf von System.runFinalizersOnExit (true) stellt sicher, dass alle Objekte finalisiert und beim Beenden der Anwendung Müll gesammelt werden. Zum Beispiel:

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

    /*
     * Notify the system to finalize and collect all objects of the
     * application on exit so that the process running the application can
     * be killed by the system without causing issues. NOTE: If this is set
     * to true then the process will not be killed until all of its threads
     * have closed.
     */
    System.runFinalizersOnExit(true);

    /*
     * Force the system to close the application down completely instead of
     * retaining it in the background. The process that runs the application
     * will be killed. The application will be completely created as a new
     * application in a new process if the user starts the application
     * again.
     */
    System.exit(0);
}

Schließlich benachrichtigt Android eine Anwendung nicht über das Ereignis HOME- Taste, sodass Sie die Anwendung nicht schließen können, wenn die HOME- Taste gedrückt wird. Android reserviert das HOME- Schlüsselereignis für sich, sodass ein Entwickler Benutzer nicht daran hindern kann, ihre Anwendung zu verlassen.

Sie können im Tag für die erste Aktivität auch noHistory = "true" angeben oder die erste Aktivität beenden, sobald Sie die zweite starten (wie David sagte).

AFAIK, "Schließen erzwingen" beendet den Prozess, der die JVM hostet, in der Ihre Anwendung ausgeführt wird, und System.exit () beendet die JVM, in der Ihre Anwendungsinstanz ausgeführt wird. Beide sind abrupte Abbrüche und für den normalen Anwendungsfluss nicht ratsam.

Ebenso wenig ist es ratsam, Ausnahmen zu erfassen, um Logikflüsse abzudecken, die ein Programm möglicherweise durchführt.

Ich benutze diese Methode, um die Aktivitäten zu schließen!

public static void closeAllBelowActivities(Activity current) {
    boolean flag = true;
    Activity below = current.getParent();
    if (below == null)
        return;
    System.out.println("Below Parent: " + below.getClass());
    while (flag) {
        Activity temp = below;
        try {
            below = temp.getParent();
            temp.finish();
        } catch (Exception e) {
            flag = false;
        }
    }
}

Wenn Sie die zweite Aktivität starten, wird finish()die erste sofort ausgeführt:

startActivity(new Intent(...));
finish();

android.os.Process.killProcess(android.os.Process.myPid()); funktioniert gut, aber es wird empfohlen, dass sich die Android-Plattform um die Speicherverwaltung kümmert :-)

Sie können System.exit () nicht ausführen, es ist nicht sicher.

Sie können dies tun: Process.killProcess (Process.myPid ());

Ich benutze das:

1) Die übergeordnete Aktivität ruft die sekundäre Aktivität mit der Methode "startActivityForResult" auf.

2) In der sekundären Aktivität, wenn geschlossen wird:

int exitCode = 1; // Select the number you want
setResult(exitCode);
finish();

3) Überschreiben Sie in der übergeordneten Aktivität die Methode "onActivityResult":

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    int exitCode = 1;
    if(resultCode == exitCode) {
        super.setResult(exitCode); // use this if you have more than 2 activities
        finish();
    }
}

Das funktioniert gut für mich.

Verwenden Sie die finishMethode. Es ist die einfachere und einfachere Methode.

this.finish();

Beachten Sie, dass bei der Arbeit mit Anwendungen, die dauerhafte Socket-Verbindungen verwenden, die finish()Methode die Verbindung nicht freigibt. Unter normalen Umständen finish()ist dies die beste Option. Wenn Sie jedoch unbedingt eine App beenden und alle verwendeten Ressourcen freigeben müssen, verwenden Sie sie killProcess. Ich hatte keine Probleme damit.

Starten Sie die zweite Aktivität mit startActivityForResult und geben Sie in der zweiten Aktivität einen Wert zurück, der einmal in der onActivityResult-Methode der ersten Aktivität die Hauptanwendung schließt. Ich denke, das ist der richtige Weg, wie Android es macht.

Sie liegen falsch. Es gibt eine Möglichkeit, eine Anwendung zu beenden. In einer Klasse mit Super Class Application verwenden wir beispielsweise ein Feld killApp. Wenn wir den Begrüßungsbildschirm (erste Aktivität) in starten onResume(), setzen wir einen Parameter für false für field killApp. In jeder Aktivität, die wir haben, wenn onResume()sie am Ende aufgerufen wird, nennen wir so etwas:

if(AppClass.killApp())
    finish();

Jede Aktivität, die auf den Bildschirm kommt, muss aufgerufen werden onResume(). Wenn es aufgerufen wird, müssen wir überprüfen, ob unser Feld killAppwahr ist. Wenn dies zutrifft, werden aktuelle Aktivitäten aufgerufen finish(). Um die vollständige Aktion aufzurufen, verwenden wir die nächste Konstruktion. Zum Beispiel in der Aktion für eine Schaltfläche:

AppClass.setkillApplication(true);
   finish();
   return;

Versuche Folgendes. Für mich geht das.

ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1); 
ComponentName componentInfo = taskInfo.get(0).topActivity;
am.restartPackage(componentInfo.getPackageName());

Angenommen, Sie haben einen Aktivitätsstapel wie A> B> C> D> E. Sie befinden sich in Aktivität D und möchten Ihre App schließen. Das wirst du tun -

In Aktivität, von wo aus Sie schließen möchten (Aktivität D) -

Intent intent = new Intent(D.this,A.class);
intent.putExtra("exit", "exit");
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP| Intent.FLAG_ACTIVITY_SINGLE_TOP);
startActivity(intent);

In Ihrer RootActivity (dh Ihrer Basisaktivität, hier Aktivität A) -

@Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        if (intent.hasExtra("exit")) {
            setIntent(intent);
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (getIntent() != null) {
            if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) {
                onBackPressed();
            }
        }
    }

onNewIntent wird verwendet, da bei einer aktiven Aktivität die erste Absicht angezeigt wird, mit der sie gestartet wurde. Nicht der Neue. Für mehr Details - Dokumentation

Es ist eigentlich ganz einfach.

Ich speichere dazu ein Flag in einer statischen Variablen, die allen zur Verfügung steht. Wenn ich dann beende, setze ich dieses Flag und alle meine Aktivitäten überprüfen dieses Flag onResume. Wenn das Flag gesetzt ist, stelle ich das ausSystem.exit für diese Aktivität aus.

Auf diese Weise suchen alle Aktivitäten nach dem Flag und werden ordnungsgemäß geschlossen, wenn das Flag gesetzt ist.

Folgendes habe ich getan, um die Anwendung zu schließen: In meiner Anwendung habe ich eine Basisaktivitätsklasse und ein statisches Flag namens "applicationShutDown" hinzugefügt. Wenn ich die Anwendung schließen muss, setze ich sie auf true.

In der Basisaktivität onCreate und onResume teste ich nach dem Aufruf der Superaufrufe dieses Flag. Wenn "applicationShutDown" wahr ist, rufe ich "finish" für die aktuelle Aktivität auf.

Das hat bei mir funktioniert:

protected void onResume() {
    super.onResume();
    if(BaseActivity.shutDownApp)
    {
        finish();
        return;

    }}

Führen Sie die zweite Aktivität mit der Startaktivität für das Ergebnis aus:

Intent intent = new Intent(FirstActivity.this, SecondActivity.class);

//This line is important
intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);

startActivityForResult(intent, REQUEST_CODE);

Fügen Sie diese Funktion zur ersten Aktivität hinzu:

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if(rquestCode == REQUEST_CODE)
        if(resultCode == RESULT_CANCELED)
            finish();
}

Und fügen Sie dies der zweiten Aktivität hinzu:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {

        Log.i(TAG, "Back key pressed");
        setResult(RESULT_CANCELED);
        finish();
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

Es wird nicht empfohlen, aber Sie können es trotzdem verwenden. Verwenden Sie diese Lösung besser, wenn Sie die App beenden müssen.

Meiner Meinung nach besteht die beste Lösung darin, jede Aktivität in Ihrer App wie unten beschrieben zu beenden.

Schritt 1. Pflegen Sie eine statische Variable in der Hauptaktivität. Sagen,

public static boolean isQuit = false;

Schritt 2. Setzen Sie diese Variable beim Klicken auf das Ereignis einer Schaltfläche auf true.

mainactivity.isQuit = true;
finish();

Schritt 3. Führen Sie in jeder Aktivität Ihrer Anwendung die folgende onrestartMethode aus.

@Override
protected void onRestart() {
    // TODO Auto-generated method stub
    super.onRestart();
    if(mainactivity.isQuit)
        finish();
}

Ich habe ein ähnliches Problem gelöst: MainActivity startet BrowserActivity und ich muss die App schließen, wenn der Benutzer in BrowserActivity auf Zurück drückt - um nicht in MainActivity zurückzukehren. Also, in MainActivity:

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "sm500_Rmt.MainActivity";
    private boolean m_IsBrowserStarted = false;

und dann in OnResume:

    @Override
protected void onResume() {
    super.onResume();
    if(m_IsBrowserStarted) {
        Log.w(TAG, "onResume, but it's return from browser, just exit!");
        finish();
        return;
    }
    Log.w(TAG, "onResume");

... dann weiter mit OnResume. Und wenn Sie BrowserActivity starten:

    Intent intent = new Intent(this, BrowserActivity.class);
    intent.putExtra(getString(R.string.IPAddr), ip);
    startActivity(intent);
    m_IsBrowserStarted = true;

Und es sieht so aus, als ob es gut funktioniert! :-)