Persistenza dei dati creati in un Activity

Salve,
nella mia applicazione ho due problemi di persistenza dei dati.

1
Leggo dei dati da un database, li passo ad una activity e devo mantenerli in memoria per dei calcoli.
Per passare i dati leggo questi dal database e uso il metodo putExtra() in cui inserisco i dati letti dal database, dopo aver definito l' Intent.
Per riottenere i dati nella activity chiamata uso un Bundle e estraggo i dati.

Questo modo mi ha permesso di mantenere i dati prelevati dal database anche se cambia l' activity o viene ricreata(rotazione del display).
Mi chiedevo però se vi fosse un modo più elegante per farlo(un best practies).
A me era venuta in mente anche l'idea di creare una classe che mappi la tabella del database, composta da soli metodi getter e setter, da tenere in vita nell' applicazione ma non so se si può e ne valga la pena.

2
una volta che sono nella seconda activity alla pressione di un bottone faccio apparire una scacchiera disegnata tramite un canvas.
Anche qui ruotando il display l' activity viene ricreata e perdo il disegno.
Dovrei quindi salvare il canvas e riusarlo.
Ho provato con una variabile statica che rappresenta il canvas e sembra funzionare, ma come prima, può andar bene come soluzione o in android si usa una tecnica diversa?

Spero mi possiate dare qualche dritta.
Grazie a tutti!

Ciao, puoi sicuramente migliorare la tecnica adottata.
Il modo in cui progetti la tua applicazione è indipendente dalla piattaforma.
Dovresti studiare il pattern MVC, poi più avanti puoi studiare le architetture MultiLayer.
In Android l'interfaccia grafica è costituita dalle activity.
Le activity si devono occupare di visualizzare dati già elaborati, e basta.
Quindi, partendo dal basso ti serve:
- Una classe che preleva i dati dal database
- Una classe che modella il tipo di oggetto
- Una classe che elabora gli oggetti e li prepara alla visualizzazione
- Una classe che li visualizza (L'activity)

Grazie ultrasound91
studierò bene il pattern MVC.

Partendo dal database ho realizzato una classe Helper per la creazione e update del DB.
Tramite un altra classe gestisco le query al database.
I dati ritornati da una query dovrei quindi memorizzarli in una classe che modella il tipo di oggetto(la tabella) e passare questa istanza alle activity che ne hanno bisogno, giusto?


Il problema più grande che sto trovando è salvare lo stato di un activity. Se io gli passo un istanza di questa classe che contiene i miei dati elaborati quando si ricrea l'activity perdo l'istanza.
Guardando il ciclo di vita delle activity e le chiamate ai relativi metodi, si fa uso di un Bundle per salvare i dati. Posso usarlo anche per salvare le modifiche sul Canvas?

Ti stai mettendo sulla strada giusta.
Hai detto che hai creato una classe che preleva i dati da un database. Giusto
Poi hai detto che i dati li memorizzi in una classe che modella la tabella, ma va bene anche un singolo record. Giusto.
Poi ti consiglio di fare diversamente.
Crei una classe che a livello logico mantenga i riferimenti agli oggetti modellati quindi ne faccia una elaborazione.
Sarà la classe logica a convertire gli attributi degli oggetti in stringhe e mandarli alle activity.

Pensavo alla classe per modellare l'oggetto perchè cosi potrei inserire in questa dei metodi che gli appartengono.

Praticamente dal database prendo i dati relativi ad una mattonella di un pavimento (altezza, larghezza,...) con queste informazioni dovrò disegnare una griglia(come una scacchiera).

L' applicazione, per ora spartana, si avvia con un activity che simula un login tramite un pulsante e una textbox(per ora non faccio nessun controllo di accesso).
Cliccando sul bottone apro un activity di tipo NavigationDrawerFragment che gestisce tre fragment.

In uno di questi fragment visualizzo un immagine di sfondo che rappresenta un pavimento e su questo alla pressione di un pulsante devo far apparire una griglia con le info prese dal database.

Se creo una classe che modella la mattonella potrei far accedere questa al database una sola volta (alla creazione del fragment che la usa) e salvare i suoi dati per riusarli in chiamate future. Inoltre potrei inserirci dentro il metodo che disegna la griglia(le info necessarie sono al suo interno)

Visto che al momento non so come salvare questa classe in memoria per riusarla allora ho pensato di implementare direttamente nel fragment la chiamata al DB e la creazione della griglia. Cosi però quando si ricrea il fragment faccio sempre un accesso al db e perdo il disegno.

La classe che mantiene i riferimenti agli oggetti credo che per ora non mi serva in quanto ho solo questo oggetto da gestire.

Però tu pensa a cosa succede quando si lavora in un team.
Bisogna dividersi i compiti.
Esempio: "creare un'app che preleva delle informazioni su delle automobili, e visualizza solo quelle relative a bmw".
Nel team potrebbero esserci tre programmatori.
Uno può creare la classe che preleva tutte le informazioni dal database,
uno può creare la classe che filtra le informazioni,
uno può creare la classe activity che visualizza le informazioni già filtrate.
Oltre al fatto che ciò permette di creare programmi più ordinati dal punto di vista del codice, permette di andare avanti con progetti di una certa complessità, che senza organizzazione non potrebbero realizzarsi.

Giusto, infatti ragionando nel mio modo mi son subito bloccato.

Quindi ho deciso di fare
una classe che modella la mattonella,
il fragment che si occupa del layout e
una classe di controllo, che farà da raccordo tra queste, e si occuperà di chiamare il DB e inizializzare la classe mattonella.

Nella classe di raccordo gestisco le elaborazioni da passare al fragment (creare il canvas, disegnare la griglia e passare il risultato al fragment che visualizza).

Da come mi suggerisci te però l'accesso al DB lo dovrei fare direttamente dalla classe mattonella(ho capito bene?), quella che fa da raccordo invece su richiesta del fragment prenderà i dati da questa disegna il canvas e lo ripassa al fragment per visualizzarlo(questo è il pattern MVC?)

Non conosco esattamente la tua problematica e di conseguenza non posso darti suggerimenti precisi.
Quello che è sicuro è che il pattern MVC non lo impari in un giorno.
Hai detto che hai delle mattonelle e devi visualizzarle.
Dunque: una mattonella ha una larghezza, una altezza, una lunghezza, un colore, un tipo di materiale.
Tu queste informazioni le prelevi e le metti in una classe. Questa classe può avere un metodo per calcolare il volume e il peso della mattonella.

Suggerimenti precisi capisco che è difficile, è già molto quello che mi stai dicendo e ti ringrazio.
Il pattern MVC lo studierò bene cosi da consentirmi di focalizzare l'attenzione su porzioni dell' applicazione e farla crescere a moduli.

Per quanto riguarda il mio problema, ho nel DB i dati di una mattonella e questo l'hai capito :). Userò per il momento solo le sue misure(altezza e larghezza in pixel) per creare una scacchiera con un certo numero di righe e colonne. Ogni quadrato della scacchiera avrà le dimensioni della mattonella.

Partendo per passi quindi, prendo i dati e inizializzo la relativa classe.

Ti metto il codice di quello che ho fatto fin ora, dove non implemento controlli, per farti capire dove faccio l'inizializzazione dei dati.

codice:

---


public class Mattonella{
 
  private int altezza;
  private int larghezza;

  // Il costruttore esegue la chiamata al DB e inizializza i valori
  public Mattonella(){

      // classe che gestisce l'accesso al DB e la query
      DataBaseManager manager = new DataBaseManager(context);
     
      Cursor crs = manager.getMattonella();
     
      crs.moveToFirst();
     
      altezza = crs.getInt(....);
      larghezza = crs.getInt(....);

      crs.close();
      manager.close();
 
  }

  public int getAltezza(){ return altezza; }
  public int getLarghezza(){ return laghezza; }

}

---

Il dubbio è:
La classe che modella la mattonella può interessarsi della chiamata al DB per avere i dati(come ho fatto io nel costruttore) o è giusto che riceva solo i dati già prelevati da qualcun altro(gli passo i dati come parametri al costruttore)?

Io farei così: nella classe che modella la mattonella realizzerei un metodo con un valore di ritorno che è un oggetto mattonella.
Questo metodo si occupa di interrogare il database mediante un id e costruire la mattonella.
Poi puoi fare un altro metodo che interroga il database per chiedere la lista degli id.
In questo modo poi potrai fare un'interrogazione per ogni id.
Immagina di avere una città, e lo schemo può visualizzare un quartiere.
Allora interrogherai il database per chiedere un insieme ridotto di record, non tutti.
Comunque queste cose bisogna rifletterle bene prima di scrivere il codice.