Speichern des Android Activity-Status mit Save Instance State

Müssen Sie zum überschreiben onSaveInstanceState(Bundle savedInstanceState) und schreiben Sie die Anwendung Status-Werte, die Sie ändern möchten, um die Bundle parameter wie diese:

@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
  super.onSaveInstanceState(savedInstanceState);
  //Save UI state changes to the savedInstanceState.
  //This bundle will be passed to onCreate if the process is
  //killed and restarted.
  savedInstanceState.putBoolean("MyBoolean", true);
  savedInstanceState.putDouble("myDouble", 1.9);
  savedInstanceState.putInt("MyInt", 1);
  savedInstanceState.putString("MyString", "Welcome back to Android");
  //etc.
}

Bundle ist im wesentlichen eine Möglichkeit zum speichern eines NVP (Name-Value-Pair-Mädchen") anzeigen, und es wird übergeben, um onCreate() und auch onRestoreInstanceState() wo würden Sie extrahieren Sie die Werte wie diese:

@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
  super.onRestoreInstanceState(savedInstanceState);
  //Restore UI state from the savedInstanceState.
  //This bundle has also been passed to onCreate.
  boolean myBoolean = savedInstanceState.getBoolean("MyBoolean");
  double myDouble = savedInstanceState.getDouble("myDouble");
  int myInt = savedInstanceState.getInt("MyInt");
  String myString = savedInstanceState.getString("MyString");
}

Würden Sie in der Regel verwenden Sie dieses Verfahren zum speichern von Instanzen-Werte für Ihre Anwendung (Auswahl, nicht gespeicherte Texte, etc.).

InformationsquelleAutor der Antwort Reto Meier

Beachten Sie, dass es NICHT sicher zu verwenden onSaveInstanceState und onRestoreInstanceState für persistente Daten, laut der Dokumentation auf Aktivität Staaten in http://developer.android.com/reference/android/app/Activity.html.

Heißt das Dokument (in den "Activity Lifecycle"):

Beachten Sie, dass es wichtig ist zu sparen
persistente Daten in onPause() statt
der onSaveInstanceState(Bundle)
weil die später nicht Teil der
lifecycle callbacks, also nicht
aufgerufen, in jeder situation, wie beschrieben
in seiner Dokumentation.

In anderen Worten, setzen Sie Ihre save - /restore-code für die persistenten Daten in onPause() und onResume()!

BEARBEITEN: Für die weitere Klärung, hier ist die onSaveInstanceState() Dokumentation:

Diese Methode wird aufgerufen, bevor eine Aktivität darf getötet werden, so dass, wenn es
kommt zurück einige Zeit in der Zukunft kann es wieder sein Zustand. Für
Beispiel falls die Aktivität B gestartet wird vor der Aktivität Ein, und an einigen
Punkt Aktivität, die getötet wird, um Ressourcen freizugeben, die Tätigkeit Einer haben
eine chance, um zu speichern Sie den aktuellen Status des user-interface über das
- Methode, so dass, wenn der Benutzer erneut Aktivität Ein, die den Zustand der
Benutzeroberfläche wiederhergestellt werden können, die über onCreate(Bundle) oder
onRestoreInstanceState(Bundle).

InformationsquelleAutor der Antwort Steve Moseley

Dies ist ein klassisches 'gotcha' von Android Entwicklung. Es gibt hier zwei Probleme:

• Es ist eine subtile Framework Android-bug, der stark erschwert das Anwendungs-stack-management bei der Entwicklung, zumindest auf legacy-Versionen (nicht ganz sicher, ob/Wann/wie es behoben wurde). Ich werde diesen Fehler weiter unten.
• Die 'normale' oder vorgesehenen Art und Weise zu verwalten, das Problem ist, selbst, ziemlich kompliziert mit der Dualität von onPause/onResume und onSaveInstanceState/onRestoreInstanceState

Browsing über alle diese threads, ich vermute, dass viel von der Zeit, die die Entwickler sprechen über diese zwei verschiedene Dinge gleichzeitig ... daher die Verwirrung und Berichte von "das funktioniert nicht für mich".

Zunächst ist zu klären, den 'soll' - Verhalten: onSaveInstance und onRestoreInstance sind zerbrechlich und nur für den vorübergehenden Zustand. Die bestimmungsgemäße Verwendung (afaict) zu behandeln Aktivität Erholung, wenn das Telefon gedreht wird (Ausrichtung ändern). In anderen Worten, die beabsichtigte Verwendung ist, wenn Sie Ihre Tätigkeit noch logisch 'on top', aber trotzdem muss erneut instanziiert werden, indem das system. Die gespeicherten Bundle wird nicht dauerhaft außerhalb des Prozess - /memory/gc, so dass Sie nicht wirklich auf diese angewiesen sind, wenn Ihre Aktivität geht in den hintergrund. Ja, vielleicht ist Ihre Tätigkeit das Gedächtnis wird überleben seiner Reise in den hintergrund und die Flucht GC, aber das ist nicht zuverlässig (noch ist es vorhersehbar).

Also, wenn Sie haben ein Szenario, wo es sinnvoll ist "user" Fortschritt "oder Zustand, der beibehalten werden sollte zwischen "startet" der Anwendung ist, die Anleitung zu verwenden, onPause und onResume. Sie müssen wählen Sie und bereiten Sie eine persistente Speicherung selbst.

ABER - es ist ein sehr verwirrender Fehler, erschwert dies alles. Details sind hier:

http://code.google.com/p/android/issues/detail?id=2373

http://code.google.com/p/android/issues/detail?id=5277

Grundsätzlich, wenn Ihre Anwendung gestartet wird mit der SingleTask-flag, und dann später, Sie starten Sie es von der Startseite oder in der launcher-Menü, dann, dass nachfolgende Aufruf erstellen Sie eine NEUE Aufgabe ... Sie werden effektiv zwei unterschiedliche Instanzen der app, die die gleichen Stapel ... das aber sehr seltsam, sehr schnell. Dies scheint zu passieren, wenn Sie starten Sie Ihre app während der Entwicklung (z.B. von Eclipse oder Intellij), so dass sich Entwickler in dieser eine Menge. Aber auch durch einige der app-store-update-Mechanismen (so es eine Wirkung auf Ihre Nutzer als auch).

Ich kämpfte sich durch diese threads für Stunden, bevor ich erkannte, dass meine Haupt-Frage war dieser bug, nicht den vorgesehenen Rahmen Verhalten. Ein großer writeup und Abhilfe (UPDATE: siehe unten) scheint von user @kaciula in dieser Antwort:

Home-Taste drücken Verhalten

UPDATE Juni 2013: Monate später, habe ich endlich den "richtigen" Lösung. Sie brauchen nicht zu bewirtschaften, stateful startedApp flags selbst sind, können Sie erkennen, diese aus dem Rahmen und die Kaution entsprechend. Ich benutze dies in der Nähe der Beginn meiner LauncherActivity.onCreate:

if (!isTaskRoot()) {
    Intent intent = getIntent();
    String action = intent.getAction();
    if (intent.hasCategory(Intent.CATEGORY_LAUNCHER) && action != null && action.equals(Intent.ACTION_MAIN)) {
        finish();
        return;
    }
}

InformationsquelleAutor der Antwort Mike Repass

Beide Methoden sind nützlich und gültig ist, und beide sind am besten geeignet für verschiedene Szenarien:

1. Sie die Anwendung beenden und neu öffnet, es zu einem späteren Zeitpunkt, aber die Anwendung muss neu laden der Daten aus der letzten Sitzung – das erfordert eine persistent-storage-Ansatz wie die Verwendung von SQLite.
2. Der Umschaltung auf Anwendung und kommt dann wieder auf die ursprüngliche und abholen will, wo Sie aufgehört haben - save-und restore-bundle von Daten (wie etwa Status der Anwendung Daten) in onSaveInstanceState() und onRestoreInstanceState() ist in der Regel ausreichend.

Wenn Sie den Zustand sichern von Daten in einer beständigen Art und Weise, es kann nachgeladen werden, die in einem onResume() oder onCreate() (oder eigentlich auf jeder lifecycle-call). Dies kann oder möglicherweise nicht gewünschtes Verhalten. Wenn Sie es speichern in einem bundle-in eine InstanceState ist, dann ist es vergänglich und ist nur geeignet für die Speicherung von Daten zur Verwendung in der gleichen Benutzer 'Sitzung' (ich verwende den Begriff session-Locker), aber nicht zwischen den "Sitzungen".

Ist es nicht, dass ein Ansatz besser ist als das andere, wie alles, es ist nur wichtig zu verstehen, was Verhalten, die Sie benötigen und wählen Sie die am besten geeignete Ansatz.

InformationsquelleAutor der Antwort David

Denke ich, dass ich die Antwort gefunden. Lassen Sie mich sagen, was ich getan haben, in einfachen Worten:

Angenommen ich habe zwei Aktivitäten, activity1 und activity2 und ich bin mit der Navigation von activity1, activity2 (ich habe getan, einige Werke in activity2) und wieder zurück zur übung 1, indem Sie auf eine Schaltfläche in activity1. Jetzt, an diesem Punkt wollte ich zurück zu gehen, um activity2, und ich will sehen, wie meine activity2 in der gleichen Bedingung, als ich den letzten Links activity2.

Für die oben genannten Szenario, was ich getan habe, ist, dass in der manifest habe ich einige änderungen gemacht wie:

<activity android:name=".activity2"
          android:alwaysRetainTaskState="true"      
          android:launchMode="singleInstance">
</activity>

Und in der activity1 auf die Schaltfläche click-Ereignis habe ich wie folgt vorgenommen:

Intent intent = new Intent();
intent.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
intent.setClassName(this,"com.mainscreen.activity2");
startActivity(intent);

Und in activity2 auf button-click-Ereignis habe ich wie folgt vorgenommen:

Intent intent=new Intent();
intent.setClassName(this,"com.mainscreen.activity1");
startActivity(intent);

Nun, was passieren wird, ist, dass unabhängig von den änderungen, die wir vorgenommen haben, in der activity2, nicht verloren gehen, und wir können activity2 in den gleichen Zustand wie wir linken früher.

Ich glaube, das ist die Antwort, und das funktioniert gut für mich. Korrigieren Sie mich, wenn ich falsch bin.

InformationsquelleAutor der Antwort roy mathew

Neuerstellung einer Aktivität

Gibt es ein paar Szenarien, in denen Ihre Aktivität zerstört wird, die durch normalen app-Verhalten, wie wenn der Benutzer die Zurück-Taste drückt oder Ihre Aktivität signalisiert seine eigene Zerstörung durch den Aufruf finish(). Das system kann auch zerstören Sie Ihre Aktivität, wenn es gerade beendet und wurde nicht in eine lange Zeit verwendet oder die Vordergrund-Aktivität erfordert mehr Ressourcen, damit das system muss heruntergefahren Hintergrundprozesse zu erholen Speicher.

Wenn Ihr activity ist zerstört, weil der Benutzer die Taste Zurück oder die activity beendet sich das system das Konzept, dass Activity Instanz ist für immer verschwunden, da sich das Verhalten zeigt die Aktivität nicht mehr benötigt wird. Wenn das system jedoch zerstört die Aktivität aufgrund von system-Einschränkungen (und nicht als normale app-Verhalten), auch wenn die eigentliche Tätigkeit Instanz gegangen ist, merkt sich das system, dass es existiert so dass, wenn der Benutzer zurück navigiert, legt das system eine neue Instanz der Tätigkeit mit einem Satz von gespeicherten Daten, beschreibt den Zustand der Aktivität, wenn es war destroyed. Die gespeicherten Daten, die das system verwendet, um den vorherigen Zustand wiederherzustellen, wird als "Instanz-Status" und ist eine Sammlung von Schlüssel-Wert-Paare gespeichert, die im Bundle-Objekt.

Speichern zusätzliche Daten über die Aktivität, Status, müssen Sie überschreiben die onSaveInstanceState () - callback-Methode. Das system ruft diese Methode auf, wenn der Benutzer verlässt Ihre Tätigkeit und übergibt ihm den Bundle-Objekt gespeichert für den Fall, dass Sie Ihre Aktivität zerstört wird unerwartet beendet. Wenn das system erstellen muss die Aktivität Instanz später, übergibt er das gleiche Bundle-Objekt sowohl für die onRestoreInstanceState() und onCreate() Methoden.

Als das system beginnt, stoppen Sie Ihre Aktivität, es ruft onSaveInstanceState() (1) so können Sie festlegen, welche zusätzlichen Daten Sie speichern möchten, im Falle der Aktivität Instanz erneut erstellt werden muss. Wenn die activity zerstört wird und die gleiche Instanz neu erstellt werden muss, übergibt das system den Staat definierten Daten (1) sowohl die onCreate() Methode (2) und die onRestoreInstanceState() Methode (3).

Speichern Sie Ihre Activity Zustand

Als Ihre Aktivität beginnt zu stoppen, ruft das system onSaveInstanceState() so kann Ihre Aktivität speichern Status-Informationen mit einer Auflistung von Schlüssel-Wert-Paaren. Die Standardimplementierung dieser Methode speichert Informationen über den Zustand der Aktivität view-Hierarchie, wie Sie den text in eine EditText widget oder die scroll-position des ListView.

Speichern zusätzliche Status-Informationen für Ihre Tätigkeit, die Sie implementieren müssen onSaveInstanceState() und fügen Sie Schlüssel-Wert-Paaren auf das Bundle-Objekt. Zum Beispiel:

  static final String STATE_SCORE = "playerScore";
  static final String STATE_LEVEL = "playerLevel";

  @Override
  public void onSaveInstanceState(Bundle savedInstanceState) {
  //Save the user's current game state
  savedInstanceState.putInt(STATE_SCORE, mCurrentScore);
  savedInstanceState.putInt(STATE_LEVEL, mCurrentLevel);

  //Always call the superclass so it can save the view hierarchy state
  super.onSaveInstanceState(savedInstanceState);
}

Achtung: rufen Sie Immer die Oberklasse Umsetzung von onSaveInstanceState() also die default-Implementierung sparen können den Status der view-Hierarchie.

Wiederherstellung Ihrer Activity Zustand

Wenn Ihre Aktivität wird wiederhergestellt, nachdem es zuvor war zerstört, Sie erholen Ihre gespeicherten Zustand von dem Bündel, das system übergibt Ihre Aktivität. Sowohl die onCreate() und onRestoreInstanceState() callback-Methoden erhalten die gleichen Bundle enthält die Instanz-Status-Informationen.

Weil die onCreate() - Methode aufgerufen wird, ob das system ist das erstellen einer neuen Instanz der Aktivität oder Neuerstellen einer vorherigen, müssen Sie überprüfen, ob der Staat Bundle null ist, bevor Sie versuchen, es zu Lesen. Wenn es null ist, dann ist das system erstellen einer neuen Instanz der Aktivität, anstatt die Wiederherstellung einer früheren eine, die zerstört wurde.

Zum Beispiel, hier ist, wie können Sie wieder einige Stand-Daten in onCreate():

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState); //Always call the superclass first

 //Check whether we're recreating a previously destroyed instance
 if (savedInstanceState != null) {
    //Restore value of members from saved state
    mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
    mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
 } else {
    //Probably initialize members with default values for a new instance
 }

 }

Anstelle der Wiederherstellung der Zustand, in onCreate() Sie können wählen, zu implementieren onRestoreInstanceState(), die das system ruft nach der onStart() Methode. Das system ruft onRestoreInstanceState() nur, wenn es einen gespeicherten Zustand wiederherstellen, so brauchen Sie nicht, um zu überprüfen, ob das Bundle ist null:

  public void onRestoreInstanceState(Bundle savedInstanceState) {
  //Always call the superclass so it can restore the view hierarchy
  super.onRestoreInstanceState(savedInstanceState);

  //Restore state members from saved instance
  mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
  mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

InformationsquelleAutor der Antwort Ravi Vaghela

Mittlerweile Mach ich im Allgemeinen keine Verwendung mehr

Bundle savedInstanceState & Co

live-Zyklus ist für die meisten Tätigkeiten zu kompliziert und nicht notwendig.
Und google erklärt selbst, es ist auch NICHT zuverlässig.

Mein Weg ist, um änderungen zu speichern sofort in den Einstellungen

 SharedPreferences p;
 p.edit().put(..).commit()

in irgendeiner Weise SharedPreferences arbeiten ähnlich wie Bundles.
Und natürlich, zuerst auf solche Werte werden rot von Einstellungen.

Im Fall von komplexen Daten, die Sie verwenden Sqlite anstelle von Einstellungen.

Wenn Sie dieses Konzept, die Aktivität weiterhin die zuletzt gespeicherten Zustand, unabhängig davon, ob es war ein erstes öffnen Sie mit Neustarts zwischendurch oder ein wieder öffnen, da die back-stack.

InformationsquelleAutor der Antwort stefan bachert

Antwort auf die ursprüngliche Frage direkt. savedInstancestate ist null, weil Ihre Tätigkeit ist niemals neu erstellt.

Ihre Tätigkeit wird nur neu erstellt werden, die einen Zustand als Paket:

• Änderungen an der Konfiguration wie z.B. ändern der Ausrichtung oder Telefon Sprache kann, erfordert eine neue aktivitätsinstanz erstellt werden.
• Kehren Sie zurück, um die app aus dem hintergrund, nachdem das OS zerstört die Aktivität.

Wird Android vernichten hintergrund Aktivitäten, wenn Sie über genügend Arbeitsspeicher verfügt oder nachdem Sie schon in den hintergrund-für einen längeren Zeitraum.

Beim testen Sie Ihr hello-world-Beispiel es gibt ein paar Wege zu verlassen und zurückzukehren, um die Aktivität.

• , Wenn Sie die zurück-Taste drücken Sie die Aktivität beendet ist. Re-Start der app ist eine BRANDNEUE Instanz. Sie sind nicht die Wiederaufnahme aus dem hintergrund auf alle.
• , Wenn Sie drücken Sie die home-Taste oder verwenden Sie den task-switcher die Aktivität geht in den hintergrund. Bei der Navigation zurück zur Anwendung onCreate wird nur aufgerufen, wenn die Activity zerstört werden mussten.

In den meisten Fällen, wenn Sie nur mit drücken der home und dann starten Sie die app erneut, die Aktivitäten müssen nicht neu erstellt werden. Es existiert bereits im Speicher, so onCreate() wird nicht aufgerufen werden.

Gibt es eine option unter Einstellungen -> Entwickler-Optionen "Don' T keep activities". Wenn es aktiviert wird Android immer zerstören, Aktivitäten und erstellen Sie, wenn Sie im hintergrund. Dies ist eine großartige option zu verlassen, aktiviert bei der Entwicklung, weil es simuliert den worst-case-Szenario. ( Eine low-memory-Geräte recycling Ihrer Tätigkeiten die ganze Zeit ).

Die anderen Antworten sind wertvoll, Sie vermitteln Ihnen die richtigen Möglichkeiten, um zu speichern Zustand, aber ich hatte nicht das Gefühl, Sie wirklich beantwortet, WARUM dein code nicht funktioniert in der Weise, die Sie erwartet.

InformationsquelleAutor der Antwort Jared Kells

Mein problem war, dass ich brauchte Beharrlichkeit, die nur während der Lebensdauer der Anwendung (D. H. eine einzelne Ausführung einschließlich der Start-weitere sub-Aktivitäten innerhalb der gleichen app und drehen des Geräts, etc.). Ich habe versucht, verschiedene Kombinationen der oben genannten Antworten, aber nicht bekommen, was ich wollte, in allen Situationen. Am Ende, was für mich gearbeitet wurde um einen Verweis auf die savedInstanceState während onCreate:

mySavedInstanceState=savedInstanceState;

verwenden, um zu erhalten der Inhalt meiner variable, wenn ich Sie brauchte, entlang der Linien von:

if (mySavedInstanceState !=null) {
   boolean myVariable = mySavedInstanceState.getBoolean("MyVariable");
}

Benutze ich onSaveInstanceStateund onRestoreInstanceState wie oben vorgeschlagen, aber ich denke, ich könnte auch oder alternativ meine Methode zum speichern der Variablen, wenn Sie sich ändert (z.B. mit putBoolean)

InformationsquelleAutor der Antwort torwalker

Grundsätzlich gibt es zwei Wege zu implementieren, dies zu ändern.

1. mit onSaveInstanceState() und onRestoreInstanceState().
2. Im manifest android:configChanges="orientation|screenSize".

Ich wirklich nicht empfehlen die Verwendung der zweiten Methode. Da in einem meiner Erfahrung es war, die die Hälfte des Display schwarz beim drehen vom hoch-ins Querformat und Umgekehrt.

Unter Verwendung der ersten Methode, die oben erwähnten , wir können das beibehalten von Daten, wenn die Ausrichtung geändert wird oder irgendeine config-änderung geschieht.
Ich kenne einen Weg, in dem Sie speichern können jede Art von Daten in savedInstance state-Objekt.

Beispiel: Betrachten Sie einen Fall, wenn Sie wollen, bestehen Json-Objekt.
erstellen Sie eine Modell-Klasse mit Getter und setter .

class MyModel extends Serializable{
JSONObject obj;

setJsonObject(JsonObject obj)
{
this.obj=obj;
}

JSONObject getJsonObject()
return this.obj;
} 
}

Jetzt in Ihrer Tätigkeit in onCreate und onSaveInstanceState-Methode tun die folgende. Es wird in etwa so Aussehen:

@override
onCreate(Bundle savedInstaceState){
MyModel data= (MyModel)savedInstaceState.getSerializable("yourkey")
JSONObject obj=data.getJsonObject();
//Here you have retained JSONObject and can use.
}


@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
//Obj is some json object 
MyModel dataToSave= new MyModel();
dataToSave.setJsonObject(obj);
oustate.putSerializable("yourkey",dataToSave); 

}

InformationsquelleAutor der Antwort Krishna

Hier ist ein Kommentar von Steve Moseley's Antwort (von ToolmakerSteve) , setzt die Dinge in Perspektive (in der ganzen onSaveInstanceState vs onPause, east cost vs west Kosten-saga)

@VVK - ich teilweise widersprechen. Einige Arten verlassen eine app nicht auslösen
onSaveInstanceState (oSIS). Dies schränkt die Nützlichkeit von oSIS. Seine
lohnt sich die Unterstützung, für minimale OS-Ressourcen, aber wenn eine app will
den Benutzer auf den Zustand, egal, wie die app war
verlassen, ist es notwendig, einen persistent-storage-Ansatz statt.
Ich benutze onCreate prüfen bündeln, und wenn es fehlt, dann schauen Sie
persistent-storage. Dies zentralisiert den Entscheidungsprozess. Ich kann
nach einem Absturz wiederherstellen, oder zurück-Taste beenden oder benutzerdefiniertes Menüelement Beenden, oder
Holen Sie sich zurück zu Bildschirm-Benutzer wurde auf viele Tage später. – ToolmakerSteve Sep
19 '15 um 10:38

InformationsquelleAutor der Antwort sαmosΛris

Nicht sicher, ob meine Lösung ist verpönt oder nicht, aber ich verwende ein gebundenes service beibehalten ViewModel Zustand. Ob Sie in Speicher speichern im service-oder beibehalten und abrufen aus einer SqlLite-Datenbank hängt von Ihren Anforderungen ab. Dies ist, was die Dienste von Geschmack tun, Sie bieten Dienstleistungen wie die Pflege, den Zustand der Anwendung und abstrakte gemeinsame business-Logik.

Wegen Speicher und Verarbeitung von Beschränkungen auf mobilen Geräten, ich behandle Android-Ansichten in einer ähnlichen Weise zu einer web-Seite. Die Seite nicht pflegen Zustand, es ist eine Reine Präsentations-layer-Komponente, deren einziger Zweck es ist, um den Zustand der Anwendung und Benutzereingaben akzeptieren. Aktuelle trends in der web-app-Architektur verwenden das alte Modell, View, Controller (MVC) - Muster, in dem die Seite ist der Ansicht, der Domain-Daten ist das Modell und der controller sitzt hinter einem web service. Das gleiche Muster eingesetzt werden können, in android mit der Ansicht gut ... der Blick, das model die Daten Ihrer domain und den Controller implementiert ist, als ein Android-gebunden-service. Wenn Sie möchten, eine Ansicht, um die Interaktion mit dem controller, binden Sie es auf starten/fortsetzen und lösen Sie auf stop/pause.

Dieser Ansatz gibt Ihnen den zusätzlichen bonus für die Durchsetzung der Trennung der Anliegen-design-Prinzip, dass alle von Euch die Geschäftslogik der Anwendung verschoben werden können, in Ihre service-das senkt die duplizierte Logik über mehrere Ansichten und ermöglicht die Ansicht durchzusetzen, ein weiteres wesentliches design-Prinzip der Einzigen Verantwortung.

InformationsquelleAutor der Antwort ComeIn

Kotlin-code:

sparen:

override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState.apply {
        putInt("intKey", 1)
        putString("stringKey", "String Value")
        putParcelable("parcelableKey", parcelableObject)
    })
}

und dann in onCreate() oder onRestoreInstanceState()

    val restoredInt = savedInstanceState?.getInt("intKey") ?: 1 //default int
    val restoredString = savedInstanceState?.getString("stringKey") ?: "default string"
    val restoredParcelable = savedInstanceState?.getParcelable<ParcelableClass>("parcelableKey") ?: ParcelableClass() //default parcelable

Add default-Werte, wenn Sie nicht wollen, haben Optionen

InformationsquelleAutor der Antwort Rafols