Salvataggio dei dati al momento della chiusura dell'app e recupero dei dati

Question

Lo so, ci sono molte domande in merito al salvataggio/recupero dei dati qui. Stavo cercando di trovare le cose da solo e ho davvero pensato di riuscire a trovare le mie risposte senza dover "fare una domanda", ma ho iniziato a chiedermi qualcosa su cui non ho visto una risposta qui.

la mia situazione:

Naturalmente, sto facendo un app. Dopo aver chiuso l'app, voglio salvare una semplice matrice di numeri (0 o 1) o valori booleani come erano. All'avvio dell'app, voglio cercare quell'array, se esiste, e recuperarlo per l'uso all'interno dell'app.

Ho iniziato a inserire il mio codice nell'attività in cui sarebbe stato utilizzato l'array. Ma ho iniziato a chiedermi se avrei dovuto copiare/incollare la funzione sostituita di onStop() in tutte le mie attività? O lo faccio nell'attività principale e in qualche modo collego le altre attività.

Fondamentalmente, indipendentemente dallo stato/attività in cui si trova l'app al momento della chiusura dell'app, voglio essere in grado di salvare l'array di int/bool e aprirlo di nuovo all'avvio dell'app.

Forse non sapevo come cercare quello che volevo, quindi spiegarlo sembrava la cosa giusta da fare.

Non mi dispiace fare più ricerche, ma se qualcuno mi indicasse nella giusta direzione almeno, sarei estremamente grato.

MODIFICA: Se c'è un modo migliore per fare ciò che voglio rispetto a quello che ho descritto (ad esempio, utilizzando uno stato diverso invece di onStop(), ad esempio), non esitare a lanciare idee. Questa è la prima volta che devo affrontare i cicli di vita delle attività e sono un po 'confuso anche dopo aver esaminato le esercitazioni di sviluppo di Android. Penso davvero che siano mal fatti nella maggior parte dei casi.

Answer 1

Utilizzare SharedPreference per memorizzare una piccola quantità di dati o utilizzare SQLite per memorizzare una grande quantità di dati. Vedere questo link

http://developer.android.com/guide/topics/data/data-storage.html

Answer 2

Il modo migliore per raggiungere questo obiettivo è:

• creare una classe. Chiamalo MySettings, o qualsiasi altra cosa che ti si addice
• in questa classe, definisci l'array di ints/booleans che stai per condividere, come statico. Crea getter & metodo setter (proprietà) per accedervi (anche come metodi statici)
• aggiungere un metodo static load() a MySettings che legge da SharedPreferences. Quando avvii l'app (nella tua prima attività o meglio in una sottoclasse di Applicazioni) chiama MySettings.load(). Questo metodo di caricamento imposta l'array
• aggiungere un metodo statico save(). Anche pubblico. Ora puoi salvare da qualsiasi punto della tua app. Questo metodo save() legge l'array e scrive in SharedPreferences

Esempio di codice:

public class MySettings { 
    private static List<Integer> data; 

    public static void load() { 
     data = new ArrayList<Integer>(); 
     // use SharedPreferences to retrieve all your data 

    } 

    public static void save() { 
     // save all contents from data 
    } 

    public static List<Integer> getData() { 
     return data; 
    } 

    public static void setData(List<Integer> data) { 
     MySettings.data = data; 
    } 
} 

Answer 3

Quando applicazione ha bisogno di risparmiare un po 'di dati persistenti si dovrebbe sempre farlo in onPause() metodo e piuttosto che onStop().Perché se il sistema operativo Android uccide il tuo processo allora i metodi onStop() e onDestroy() non vengono mai chiamati. Allo stesso modo recuperare i dati nel metodo onResume().

Answer 4

Guardando allo scopo che si desidera soddisfare, SharedPreferences è tutto ciò che si desidera.

Gli stati di documentazione:

"SharePreferences fornisce un quadro generale che permette di salvare e recuperare persistenti coppie chiave-valore di tipi di dati primitivi È possibile utilizzare SharedPreferences per salvare tutti i dati primitivi:. Booleani , float, ints, longs e stringhe. Questi dati permarranno tra le sessioni dell'utente (anche se l'applicazione viene uccisa). "

Answer 5

serializzare un oggetto e passarlo intorno al quale è più affidabile di preferenze condivise (aveva un sacco di problemi con la coerenza con preferenze comune):

public class SharedVariables { 

    public static <S extends Serializable> void writeObject(
      final Context context, String key, S serializableObject) { 

     ObjectOutputStream objectOut = null; 
     try { 
      FileOutputStream fileOut = context.getApplicationContext().openFileOutput(key, Activity.MODE_PRIVATE); 
      objectOut = new ObjectOutputStream(fileOut); 
      objectOut.writeObject(serializableObject); 
      fileOut.getFD().sync(); 
     } catch (IOException e) { 
      Log.e("SharedVariable", e.getMessage(), e); 
     } finally { 
      if (objectOut != null) { 
       try { 
        objectOut.close(); 
       } catch (IOException e) { 
        Log.e("SharedVariable", e.getMessage(), e); 
       } 
      } 
     } 
    } 

quindi utilizzare una classe da utilizzare:

public class Timestamps implements Serializable { 

private float timestampServer; 

public float getTimestampServer() { 
    return timestampServer; 
} 

public void setTimestampServer(float timestampServer) { 
    this.timestampServer = timestampServer; 
} 

} 

Poi ovunque si desidera scrivere per l'utilizzo variabile:

SharedVariables.writeObject(getApplicationContext(), "Timestamps", timestampsData);