So speichern Sie ein Android-Aktivitäts-Status mit speichern der Instanz Staat?

Den savedInstanceState ist nur für das speichern des Zustands im Zusammenhang mit einer Laufenden Instanz einer Aktivität, zum Beispiel aktuelle navigation oder Auswahl-info, so dass, wenn Android zerstört und erschafft eine Aktivität, kann es wieder wie es vorher war. Finden Sie in der Dokumentation für onCreate und onSaveInstanceState

Mehr lange gelebt Zustand, erwägen Sie die Verwendung einer SQLite-Datenbank, einer Datei oder Einstellungen. Sehen Speichern Von Persistenten Zustand.

Mein Kollege schrieb einen Artikel zu erklären, den Zustand der Anwendung auf Android-Geräten einschließlich der Erklärungen auf der Aktivität-Lebenszyklus und-Zustand Informationen, wie zum speichern von Status-Informationen, und speichern Staat Bundle und SharedPreferences und werfen Sie einen Blick auf hier.

Den Artikel umfasst drei Ansätze:

Speichern von lokalen Variablen/UI-control-Daten für die Lebensdauer der Anwendung (d.h. vorübergehend) mit einer Instanz Staat bundle

[Code sample – Store state in state bundle]
@Override
public void onSaveInstanceState(Bundle savedInstanceState)
{
  //Store UI state to the savedInstanceState.
  //This bundle will be passed to onCreate on next call.  EditText txtName = (EditText)findViewById(R.id.txtName);
  String strName = txtName.getText().toString();

  EditText txtEmail = (EditText)findViewById(R.id.txtEmail);
  String strEmail = txtEmail.getText().toString();

  CheckBox chkTandC = (CheckBox)findViewById(R.id.chkTandC);
  boolean blnTandC = chkTandC.isChecked();

  savedInstanceState.putString(“Name”, strName);
  savedInstanceState.putString(“Email”, strEmail);
  savedInstanceState.putBoolean(“TandC”, blnTandC);

  super.onSaveInstanceState(savedInstanceState);
}

Speichern von lokalen Variablen/UI-Steuerelement Daten zwischen Applikations-Instanzen (D. H. dauerhaft) unter Verwendung von shared preferences

[Code sample – store state in SharedPreferences]
@Override
protected void onPause()
{
  super.onPause();

  //Store values between instances here
  SharedPreferences preferences = getPreferences(MODE_PRIVATE);
  SharedPreferences.Editor editor = preferences.edit();  //Put the values from the UI
  EditText txtName = (EditText)findViewById(R.id.txtName);
  String strName = txtName.getText().toString();

  EditText txtEmail = (EditText)findViewById(R.id.txtEmail);
  String strEmail = txtEmail.getText().toString();

  CheckBox chkTandC = (CheckBox)findViewById(R.id.chkTandC);
  boolean blnTandC = chkTandC.isChecked();

  editor.putString(“Name”, strName); //value to store
  editor.putString(“Email”, strEmail); //value to store
  editor.putBoolean(“TandC”, blnTandC); //value to store
  //Commit to storage
  editor.commit();
}

Halten Objektinstanzen im Speicher aktiv zwischen Aktivitäten innerhalb einer Anwendung, Leben mit einer beibehaltenen nicht-configuration Instanz

[Code sample – store object instance]
private cMyClassType moInstanceOfAClass; //Store the instance of an object
@Override
public Object onRetainNonConfigurationInstance()
{
  if (moInstanceOfAClass != null) //Check that the object exists
      return(moInstanceOfAClass);
  return super.onRetainNonConfigurationInstance();
}

onSaveInstanceState wird aufgerufen, wenn das system benötigt Speicher und beendet eine Anwendung. Es wird nicht aufgerufen, wenn der Benutzer die Anwendung schließt. Also ich denke, den Zustand der Anwendung sollte auch gespeichert werden, in onPause Es sollte gerettet werden, um einige persistente Speicher wie Preferences oder Sqlite

Status speichern ist ein Schlamassel, am besten soweit ich bin besorgt. Wenn Sie brauchen, um zu speichern persistenter Daten, verwenden Sie einfach einen SQLite Datenbank. Android macht es SOOO einfach.

Etwas wie dieses:

import java.util.Date;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class dataHelper {

    private static final String DATABASE_NAME = "autoMate.db";
    private static final int DATABASE_VERSION = 1;

    private Context context;
    private SQLiteDatabase db;
    private OpenHelper oh ;

    public dataHelper(Context context) {
        this.context = context;
        this.oh = new OpenHelper(this.context);
        this.db = oh.getWritableDatabase();
    }

    public void close() {
        db.close();
        oh.close();
        db = null;
        oh = null;
        SQLiteDatabase.releaseMemory();
    }


    public void setCode(String codeName, Object codeValue, String codeDataType) {
        Cursor codeRow = db.rawQuery("SELECT * FROM code WHERE codeName = '"+  codeName + "'", null);
        String cv = "" ;

        if (codeDataType.toLowerCase().trim().equals("long") == true){
            cv = String.valueOf(codeValue);
        }
        else if (codeDataType.toLowerCase().trim().equals("int") == true)
        {
            cv = String.valueOf(codeValue);
        }
        else if (codeDataType.toLowerCase().trim().equals("date") == true)
        {
            cv = String.valueOf(((Date)codeValue).getTime());
        }
        else if (codeDataType.toLowerCase().trim().equals("boolean") == true)
        {
            String.valueOf(codeValue);
        }
        else
        {
            cv = String.valueOf(codeValue);
        }

        if(codeRow.getCount() > 0) //exists-- update
        {
            db.execSQL("update code set codeValue = '" + cv +
                "' where codeName = '" + codeName + "'");
        }
        else //does not exist, insert
        {
            db.execSQL("INSERT INTO code (codeName, codeValue, codeDataType) VALUES(" +
                    "'" + codeName + "'," +
                    "'" + cv + "'," +
                    "'" + codeDataType + "')" );
        }
    }

    public Object getCode(String codeName, Object defaultValue){

        //Check to see if it already exists
        String codeValue = "";
        String codeDataType = "";
        boolean found = false;
        Cursor codeRow  = db.rawQuery("SELECT * FROM code WHERE codeName = '"+  codeName + "'", null);
        if (codeRow.moveToFirst())
        {
            codeValue = codeRow.getString(codeRow.getColumnIndex("codeValue"));
            codeDataType = codeRow.getString(codeRow.getColumnIndex("codeDataType"));
            found = true;
        }

        if (found == false)
        {
            return defaultValue;
        }
        else if (codeDataType.toLowerCase().trim().equals("long") == true)
        {
            if (codeValue.equals("") == true)
            {
                return (long)0;
            }
            return Long.parseLong(codeValue);
        }
        else if (codeDataType.toLowerCase().trim().equals("int") == true)
        {
            if (codeValue.equals("") == true)
            {
                return (int)0;
            }
            return Integer.parseInt(codeValue);
        }
        else if (codeDataType.toLowerCase().trim().equals("date") == true)
        {
            if (codeValue.equals("") == true)
            {
                return null;
            }
            return new Date(Long.parseLong(codeValue));
        }
        else if (codeDataType.toLowerCase().trim().equals("boolean") == true)
        {
            if (codeValue.equals("") == true)
            {
                return false;
            }
            return Boolean.parseBoolean(codeValue);
        }
        else
        {
            return (String)codeValue;
        }
    }


    private static class OpenHelper extends SQLiteOpenHelper {

        OpenHelper(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
        }

        @Override
        public void onCreate(SQLiteDatabase db) {
            db.execSQL("CREATE TABLE IF  NOT EXISTS code" +
            "(id INTEGER PRIMARY KEY, codeName TEXT, codeValue TEXT, codeDataType TEXT)");
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        }
    }
}

Einen einfachen Anruf nach, dass

dataHelper dh = new dataHelper(getBaseContext());
String status = (String) dh.getCode("appState", "safetyDisabled");
Date serviceStart = (Date) dh.getCode("serviceStartTime", null);
dh.close();
dh = null;

onSaveInstanceState() für transiente Daten (renoviert in onCreate()/onRestoreInstanceState()), onPause() für persistente Daten (renoviert in onResume()).
Von Android technische Ressourcen:

onSaveInstanceState() ist als Android, wenn die Activity wird beendet und kann getötet werden, bevor es wieder aufgenommen wird! Das bedeutet, dass es speichern soll jeder Staat nötig, zu re-initialisieren, um den gleichen Zustand, wenn die Activity neu gestartet wird. Es ist das Gegenstück zu onCreate () - Methode, und in der Tat das Bundle savedInstanceState übergeben onCreate() ist dasselbe Bündel, das Sie konstruieren als outState in die onSaveInstanceState () - Methode.

onPause() und onResume() sind auch Kostenlose Methoden. onPause() wird immer aufgerufen, wenn die Aktivität endet, auch wenn wir angeregt, dass (mit einem finish () - Aufruf für Beispiel). Wir verwenden diese zum speichern der aktuellen Notiz wieder in die Datenbank. Gute Praxis ist, um alle Ressourcen, die freigegeben werden können, während eine onPause() als gut, weniger Ressourcen, wenn in den passiven Zustand.

Zu verringern, boilerplate ich verwende die folgenden interface und class Lesen/schreiben auf einem Bundle für das sparen von Instanz-Zustand.

Erstellen Sie zuerst eine Schnittstelle, die verwendet werden, um kommentieren Sie Ihre Instanz-Variablen:

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
        ElementType.FIELD
})
public @interface SaveInstance {

}

Erstellen Sie dann eine Klasse, wo die Reflexion verwendet werden, um Werte zu speichern, um das bundle:

import android.app.Activity;
import android.app.Fragment;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;

import java.io.Serializable;
import java.lang.reflect.Field;

/**
 * Save and load fields to/from a {@link Bundle}. All fields should be annotated with {@link
 * SaveInstance}.</p>
 */
public class Icicle {

    private static final String TAG = "Icicle";

    /**
     * Find all fields with the {@link SaveInstance} annotation and add them to the {@link Bundle}.
     *
     * @param outState
     *         The bundle from {@link Activity#onSaveInstanceState(Bundle)} or {@link
     *         Fragment#onSaveInstanceState(Bundle)}
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @see #load(Bundle, Object)
     */
    public static void save(Bundle outState, Object classInstance) {
        save(outState, classInstance, classInstance.getClass());
    }

    /**
     * Find all fields with the {@link SaveInstance} annotation and add them to the {@link Bundle}.
     *
     * @param outState
     *         The bundle from {@link Activity#onSaveInstanceState(Bundle)} or {@link
     *         Fragment#onSaveInstanceState(Bundle)}
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @param baseClass
     *         Base class, used to get all superclasses of the instance.
     * @see #load(Bundle, Object, Class)
     */
    public static void save(Bundle outState, Object classInstance, Class<?> baseClass) {
        if (outState == null) {
            return;
        }
        Class<?> clazz = classInstance.getClass();
        while (baseClass.isAssignableFrom(clazz)) {
            String className = clazz.getName();
            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(SaveInstance.class)) {
                    field.setAccessible(true);
                    String key = className + "#" + field.getName();
                    try {
                        Object value = field.get(classInstance);
                        if (value instanceof Parcelable) {
                            outState.putParcelable(key, (Parcelable) value);
                        } else if (value instanceof Serializable) {
                            outState.putSerializable(key, (Serializable) value);
                        }
                    } catch (Throwable t) {
                        Log.d(TAG, "The field '" + key + "' was not added to the bundle");
                    }
                }
            }
            clazz = clazz.getSuperclass();
        }
    }

    /**
     * Load all saved fields that have the {@link SaveInstance} annotation.
     *
     * @param savedInstanceState
     *         The saved-instance {@link Bundle} from an {@link Activity} or {@link Fragment}.
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @see #save(Bundle, Object)
     */
    public static void load(Bundle savedInstanceState, Object classInstance) {
        load(savedInstanceState, classInstance, classInstance.getClass());
    }

    /**
     * Load all saved fields that have the {@link SaveInstance} annotation.
     *
     * @param savedInstanceState
     *         The saved-instance {@link Bundle} from an {@link Activity} or {@link Fragment}.
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @param baseClass
     *         Base class, used to get all superclasses of the instance.
     * @see #save(Bundle, Object, Class)
     */
    public static void load(Bundle savedInstanceState, Object classInstance, Class<?> baseClass) {
        if (savedInstanceState == null) {
            return;
        }
        Class<?> clazz = classInstance.getClass();
        while (baseClass.isAssignableFrom(clazz)) {
            String className = clazz.getName();
            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(SaveInstance.class)) {
                    String key = className + "#" + field.getName();
                    field.setAccessible(true);
                    try {
                        Object fieldVal = savedInstanceState.get(key);
                        if (fieldVal != null) {
                            field.set(classInstance, fieldVal);
                        }
                    } catch (Throwable t) {
                        Log.d(TAG, "The field '" + key + "' was not retrieved from the bundle");
                    }
                }
            }
            clazz = clazz.getSuperclass();
        }
    }

}

Beispiel:

public class MainActivity extends Activity {

    @SaveInstance
    private String foo;

    @SaveInstance
    private int bar;

    @SaveInstance
    private Intent baz;

    @SaveInstance
    private boolean qux;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Icicle.load(savedInstanceState, this);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Icicle.save(outState, this);
    }

}

Hinweis: Dieser code wurde angepasst von einer Bibliothek-Projekt mit dem Namen AndroidAutowire unter der Lizenz der MIT-Lizenz.

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, die 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.

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)

Wann wird eine Aktivität erzeugt, es ist onCreate () - Methode aufgerufen wird.

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

savedInstanceState Objekt der Bundle-Klasse, die null zum ersten mal, aber es enthält Werte, wenn es neu erstellt wird. Zum speichern der Tätigkeit Stand, die Sie überschreiben müssen, onSaveInstanceState().

   @Override
    protected void onSaveInstanceState(Bundle outState) {
      outState.putString("key","Welcome Back")
        super.onSaveInstanceState(outState);       //save state
    }

legen Sie Ihre Werte in "outState" Bundle-Objekt wie outState.putString("key","Willkommen Zurück") und sparen Sie durch den Aufruf super.
Wenn Aktivität zerstört werden, es ist Staat gerettet werden, in Bundle-Objekt und kann wiederhergestellt werden, nachdem die Erholung in der onCreate () - oder onRestoreInstanceState(). Bundle erhalten in onCreate() und onRestoreInstanceState() sind die gleichen.

   @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

          //restore activity's state
         if(savedInstanceState!=null){
          String reStoredString=savedInstanceState.getString("key");
            }
    }

oder

  //restores activity's saved state
 @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
      String restoredMessage=savedInstanceState.getString("key");
    }

Hier ist ein Kommentar von Steve Moseley's Antwort (von ToolmakerSteve), das 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 bei, 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

Bekommen Aktivitäts-Status gespeicherten Daten in onCreate() müssen Sie zuerst speichern von Daten in savedInstanceState durch überschreiben SaveInstanceState(Bundle savedInstanceState) Methode.

Wenn Aktivität zerstören SaveInstanceState(Bundle savedInstanceState) Methode wird aufgerufen, und dort Daten speichern, die Sie speichern möchten. Und Sie bekommen dasselbe in onCreate() wenn Aktivität neu starten.(savedInstanceState nicht null sein, da Sie gespeichert haben, einige Daten in Sie, bevor die Aktivität zerstört)

Nicht sicher, ob meine Lösung ist verpönt oder nicht, aber ich benutze ein gebundenes service beibehalten ViewModel Zustand. Ob Sie in Speicher speichern im service-oder beibehalten und abrufen aus einer SQLite-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 Sie die Alter-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 seiend, gut ... der Blick, das model ist Ihre domain-Daten, und der 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.

Kotlin

Müssen Sie überschreiben onSaveInstanceState und onRestoreInstanceState zum speichern und abrufen von Variablen, die Sie wollen, beharrlich zu sein

Life-cycle-graph

Speichern von Variablen

public override fun onSaveInstanceState(savedInstanceState: Bundle) {
    super.onSaveInstanceState(savedInstanceState)

    //prepare variables here
    savedInstanceState.putInt("kInt", 10)
    savedInstanceState.putBoolean("kBool", true)
    savedInstanceState.putDouble("kDouble", 4.5)
    savedInstanceState.putString("kString", "Hello Kotlin")
}

Abrufen von Variablen

public override fun onRestoreInstanceState(savedInstanceState: Bundle) {
    super.onRestoreInstanceState(savedInstanceState)

    val myInt = savedInstanceState.getInt("kInt")
    val myBoolean = savedInstanceState.getBoolean("kBool")
    val myDouble = savedInstanceState.getDouble("kDouble")
    val myString = savedInstanceState.getString("kString")
    //use variables here
}