Android Kotlin Fundamentals 06.1: crea un database di sale

Questo codelab fa parte del corso Android Kotlin Fundamentals. Otterrai il massimo valore da questo corso se lavori in sequenza nei codelab. Tutti i codelab del corso sono elencati nella pagina di destinazione di Android Kotlin Fundamentals.

Introduzione

La maggior parte delle app presenta dati che devono essere conservati, anche dopo la chiusura. Ad esempio, l'app potrebbe memorizzare una playlist, un inventario di articoli di gioco, registri delle spese e delle entrate, un catalogo di costellazioni o dati sul sonno nel tempo. Normalmente, si utilizza un database per archiviare i dati permanenti.

Room è una raccolta di database che fa parte del Jetpack Android. Room si occupa di gran parte delle faccende domestiche di impostazione e configurazione dei database e rende possibile l'interazione della tua app con il database tramite normali chiamate funzione. Di seguito è riportato un Room livello di astrazione per un database SQLite. La terminologia di Room e la sintassi delle query per le query più complesse seguono il modello SQLite.

L'immagine seguente mostra in che modo il database Room si adatta all'architettura complessiva consigliata in questo corso.

Informazioni importanti

Dovresti acquisire familiarità con:

  • Creare un'interfaccia utente di base per un'app Android
  • Utilizzare attività, frammenti e viste.
  • Navigare tra i frammenti e utilizzare Safe Args (un plug-in Gradle) per trasmettere dati tra i frammenti.
  • Visualizza modelli, fabbriche di modelli e LiveData e i relativi osservatori. Questi argomenti relativi ai componenti dell'architettura sono trattati in un codelab precedente in questo corso.
  • Conoscenza di base dei database SQL e del linguaggio SQLite. Consulta SQLite Primer per una rapida panoramica o un ripasso.

Obiettivi didattici

  • Come creare e interagire con un database Room in modo da conservare i dati.
  • Come creare una classe dati che definisce una tabella nel database.
  • Come utilizzare un oggetto Data Access (DAO) per mappare le funzioni Kotlin alle query SQL.
  • Come verificare se il database funziona.

In questo lab proverai a:

  • Crea un database Room con un'interfaccia per i dati relativi al sonno notturno.
  • Testa il database utilizzando i test forniti.

In questo codelab, crei la parte del database di un'app che monitora la qualità del sonno. L'app utilizza un database per memorizzare i dati del sonno nel tempo.

L'app ha due schermate, rappresentate da frammenti, come mostrato nella figura che segue.

La prima schermata, mostrata a sinistra, ha i pulsanti per avviare e interrompere il monitoraggio. Lo schermo mostra tutti i dati relativi al sonno dell'utente. Il pulsante Cancella elimina definitivamente tutti i dati raccolti dall'app per l'utente.

La seconda schermata, mostrata a destra, consente di selezionare una valutazione della qualità del sonno. Nell'app, la valutazione è rappresentata da un valore numerico. Ai fini dello sviluppo, l'app mostra sia le icone dei volti sia gli equivalenti numerici.

Il flusso dell'utente è il seguente:

  • L'utente apre l'app e visualizza la schermata di monitoraggio del sonno.
  • L'utente tocca il pulsante Avvia. Registra l'ora di inizio e la visualizza. Il pulsante Avvia è disattivato e il pulsante Interrompi è attivato.
  • L'utente tocca il pulsante Interrompi. Registra l'ora di fine e apre la schermata relativa alla qualità del sonno.
  • L'utente seleziona un'icona relativa alla qualità del sonno. Lo schermo si chiude e la schermata di monitoraggio mostra l'ora di fine e la qualità del sonno. Il pulsante Stop è disattivato e il pulsante Start è abilitato. L'app è pronta per un'altra notte.
  • Il pulsante Cancella è abilitato ogni volta che nel database sono presenti dati. Quando l'utente tocca il pulsante Cancella, tutti i suoi dati vengono cancellati senza ricorrere a un ricorso: non c'è un messaggio di Sei sicuro,

Questa app utilizza un'architettura semplificata, come mostrato di seguito nel contesto dell'architettura completa. L'app utilizza solo i seguenti componenti:

  • Controller dell'interfaccia utente
  • Visualizza modello e LiveData
  • Un database delle stanze

Passaggio 1: scarica ed esegui l'app iniziale

  1. Scarica l'app TrackMySleepQualità-Starter da GitHub.
  2. Crea ed esegui l'app. L'app mostra l'UI del frammento SleepTrackerFragment, ma non i dati. I pulsanti non rispondono ai tocchi.

Passaggio 2: esamina l'app iniziale

  1. Dai un'occhiata ai file Gradle:
  • Il file Gradle del progetto
    Nel file build.gradle a livello di progetto, puoi notare le variabili che specificano le versioni della libreria. Le versioni utilizzate nell'app iniziale funzionano bene insieme e funzionano bene con questa app. Quando completi questo codelab, Android Studio potrebbe chiederti di aggiornare alcune versioni. Sta a te decidere se aggiornare o mantenere le versioni presenti nell'app. Se riscontri errori di compilazione, strani, prova a utilizzare la combinazione delle versioni della libreria utilizzate dall'app soluzione finale.
  • Il file Gradle del modulo. Osserva le dipendenze fornite per tutte le librerie Android Jetpack, incluse quelle di Room e le dipendenze per le coroutine.
  1. Dai un'occhiata ai pacchetti e all'interfaccia utente. L'app è strutturata in base alla funzionalità. Il pacchetto contiene file segnaposto a cui aggiungerai codice in questa serie di codelab.
  • Il pacchetto database per tutto il codice relativo al database Room.
  • I pacchetti sleepquality e sleeptracker contengono il frammento, il modello di visualizzazione e la fabbrica di modelli di visualizzazione per ogni schermata.
  1. Dai un'occhiata al file Util.kt, che contiene funzioni che consentono di visualizzare dati relativi alla qualità del sonno. Alcuni codici sono commentati perché fanno riferimento a un modello di vista creato in un secondo momento.
  2. Dai un'occhiata alla cartella androidTest (SleepDatabaseTest.kt). Utilizzerai questo test per verificare che il database funzioni come previsto.

In Android, i dati vengono rappresentati in classi di dati e i dati sono accessibili e modificati tramite chiamate di funzione. Tuttavia, nel mondo dei database sono necessarie entità e query.

  • Un'entità rappresenta un oggetto o un concetto e le relative proprietà, da archiviare nel database. Una classe di entità definisce una tabella e ogni istanza di tale classe rappresenta una riga nella tabella. Ogni proprietà definisce una colonna. Nell'app, la persona giuridica conterrà informazioni su una notte di sonno.
  • Una query è una richiesta di dati o informazioni da una tabella di database o da una combinazione di tabelle o una richiesta per eseguire un'azione sui dati. Le query comuni riguardano la ricezione, l'inserimento e l'aggiornamento delle entità. Ad esempio, puoi eseguire una query per tutte le notti di sonno registrate, ordinate per ora di inizio.

Room si occupa di tutto il lavoro per ottenere dalle classi di dati Kotlin alle entità che possono essere archiviate nelle tabelle SQLite, dalle dichiarazioni delle funzioni alle query SQL.

Devi definire ogni entità come classe di dati annotata e come interazioni come interfaccia annotata, un oggetto di accesso ai dati (DAO). Room utilizza queste classi annotate per creare tabelle nel database e le query che agiscono sul database.

Passaggio 1: crea l'entità SleepNight

In questa attività definirai una notte di sonno come classe di dati annotata.

Per una notte di sonno, devi registrare l'ora di inizio, l'ora di fine e una valutazione della qualità.

Ti servirà un ID per identificare in modo univoco la notte.

  1. Nel pacchetto database, trova e apri il file SleepNight.kt.
  2. Crea la classe dati SleepNight con i parametri di un ID, un'ora di inizio (in millisecondi), un'ora di fine (in millisecondi) e una valutazione numerica della qualità del sonno.
  • Devi inizializzare sleepQuality, quindi impostalo su -1, per indicare che non sono stati raccolti dati di qualità.
  • Devi anche inizializzare l'ora di fine. Imposta l'ora di inizio per indicare che non è stata ancora registrata alcuna ora di fine. 
data class SleepNight(
       var nightId: Long = 0L,
       val startTimeMilli: Long = System.currentTimeMillis(),
       var endTimeMilli: Long = startTimeMilli,
       var sleepQuality: Int = -1
)
  1. Prima della dichiarazione della classe, annota la classe dati con @Entity. Assegna un nome alla tabella daily_sleep_quality_table. L'argomento per tableName è facoltativo ma consigliato. Puoi cercare altri argomenti nella documentazione.

    Se richiesto, importa Entity e tutte le altre annotazioni dalla libreria androidx.
@Entity(tableName = "daily_sleep_quality_table")
data class SleepNight(...)
  1. Per identificare nightId come chiave principale, annota @PrimaryKey nella proprietà nightId. Imposta il parametro autoGenerate su true in modo che Room generi l'ID per ogni entità. Ciò garantisce che l'ID di ogni notte sia univoco. 
@PrimaryKey(autoGenerate = true)
var nightId: Long = 0L,...
  1. Annota le proprietà rimanenti con @ColumnInfo. Personalizza i nomi delle proprietà utilizzando i parametri come mostrato di seguito. 
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "daily_sleep_quality_table")
data class SleepNight(
       @PrimaryKey(autoGenerate = true)
       var nightId: Long = 0L,

       @ColumnInfo(name = "start_time_milli")
       val startTimeMilli: Long = System.currentTimeMillis(),

       @ColumnInfo(name = "end_time_milli")
       var endTimeMilli: Long = startTimeMilli,

       @ColumnInfo(name = "quality_rating")
       var sleepQuality: Int = -1
)
  1. Crea ed esegui il tuo codice per assicurarti che non contenga errori.

In questa attività definisci un oggetto di accesso ai dati (DAO). Su Android, DAO offre diversi metodi per inserire, eliminare e aggiornare il database.

Quando utilizzi un database di Room, esegui una query sul database definendo e chiamando le funzioni di Kotlin nel tuo codice. Queste funzioni di Kotlin vengono mappate alle query SQL. Tu definisci queste mappature in un DAO utilizzando le annotazioni e Room crea il codice necessario.

Pensa a un DAO che definisce un'interfaccia personalizzata per l'accesso al database.

Per le operazioni di database comuni, la libreria Room fornisce annotazioni di convenienza, come @Insert, @Delete e @Update. Per tutto il resto, è presente l'annotazione @Query. Puoi scrivere qualsiasi query supportata da SQLite.

Come bonus aggiuntivo, man mano che crei le tue query in Android Studio, il compilatore verifica la presenza di errori di sintassi nelle query SQL.

Per il database di notti di sonno, il tracker del sonno deve essere in grado di:

  • Inserisci nuove notti.
  • Aggiorna una notte esistente per aggiornare un'ora di fine e una valutazione della qualità.
  • Dormi per una determinata notte in base alla sua chiave.
  • Visualizza tutte le notti, in modo da poterle visualizzare.
  • Più notti.
  • Elimina tutte le voci nel database.

Passaggio 1: crea il DAO di SleepDatabase

  1. Nel pacchetto database, apri SleepDatabaseDao.kt.
  2. Tieni presente che interface SleepDatabaseDao ha un'annotazione con @Dao. Tutti i DAO devono avere un'annotazione con la parola chiave @Dao. 
@Dao
interface SleepDatabaseDao {}
  1. Nel corpo dell'interfaccia, aggiungi un'annotazione @Insert. Sotto @Insert, aggiungi una funzione insert() che prenda un'istanza della classe Entity SleepNight come argomento.

    Ecco fatto. Room genererà tutto il codice necessario per inserire SleepNight nel database. Quando chiami insert() dal tuo codice Kotlin, Room esegue una query SQL per inserire l'entità nel database. Nota: puoi chiamare la funzione come preferisci.
@Insert
fun insert(night: SleepNight)
  1. Aggiungi un'annotazione @Update con una funzione update() per un elemento SleepNight. L'entità aggiornata è l'entità che ha la stessa chiave di quella trasmessa. Puoi aggiornare alcune o tutte le altre proprietà dell'entità.
@Update
fun update(night: SleepNight)

Non esiste un'annotazione di convenienza per la funzionalità rimanente, quindi devi utilizzare l'annotazione @Query e fornire query SQLite.

  1. Aggiungi un'annotazione @Query con una funzione get() che accetti un argomento Long key e restituisca un valore SleepNight nulla. Vedrai un errore per un parametro mancante.
@Query
fun get(key: Long): SleepNight?
  1. La query viene fornita come parametro stringa all'annotazione. Aggiungi un parametro a @Query. Impostalo come String che è una query SQLite.
  • Seleziona tutte le colonne dalla daily_sleep_quality_table
  • WHERE in nightId corrisponde all'argomento :key.

    Osserva :key. La notazione dei due punti nella query viene utilizzata per fare riferimento agli argomenti della funzione.
("SELECT * from daily_sleep_quality_table WHERE nightId = :key")
  1. Aggiungi un altro @Query con una funzione clear() e una query SQLite a DELETE tutto da daily_sleep_quality_table. Questa query non elimina la tabella stessa.

    L'annotazione @Delete elimina un elemento e tu puoi utilizzare @Delete e fornire un elenco di notti da eliminare. Lo svantaggio è che devi recuperare o sapere cosa è presente nella tabella. L'annotazione @Delete è ideale per eliminare voci specifiche, ma non è efficace per cancellare tutte le voci da una tabella.
@Query("DELETE FROM daily_sleep_quality_table")
fun clear()
  1. Aggiungi un elemento @Query con una funzione getTonight(). Rendi SleepNight nullo da getTonight() nullo, in modo che la funzione possa gestire il caso in cui la tabella è vuota. La tabella è vuota all'inizio e dopo la cancellazione dei dati.

    Per recuperare "stasera", dal database, scrivi una query SQLite che restituisca il primo elemento di un elenco di risultati ordinato in base a nightId in ordine decrescente. Utilizza LIMIT 1 per restituire un solo elemento.
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC LIMIT 1")
fun getTonight(): SleepNight?
  1. Aggiungi un elemento @Query con una funzione getAllNights():
  • Fai in modo che la query SQLite restituisca tutte le colonne a partire da daily_sleep_quality_table, ordinate in ordine decrescente.
  • Fai in modo che getAllNights() restituisca un elenco di SleepNight entità come LiveData. Room tiene aggiornato questo LiveData, il che significa che devi recuperare esplicitamente i dati una sola volta.
  • Potresti dover importare LiveData da androidx.lifecycle.LiveData.
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC")
fun getAllNights(): LiveData<List<SleepNight>>
  1. Anche se non noterai cambiamenti visibili, esegui l'app per assicurarti che non contenga errori.

In questa attività creerai un database Room che utilizza Entity e DAO creati nell'attività precedente.

Devi creare una classe di titolare di database astratto, con l'annotazione @Database. Questa classe ha un metodo che crea un'istanza del database se il database non esiste o restituisce un riferimento a un database esistente.

Ottenere un database Room è un po' complesso, quindi ecco la procedura generale prima di iniziare con il codice:

  • Crea una classe public abstract che extends RoomDatabase. Questo corso ha la funzione di titolare del database. La classe è astratta, perché Room crea per te l'implementazione.
  • Annota la classe con @Database. Negli argomenti, dichiara le entità per il database e imposta il numero di versione.
  • All'interno di un oggetto companion, definisci una proprietà o un metodo astratto che restituisce un SleepDatabaseDao. Room genererà il corpo per te.
  • È necessaria una sola istanza del database Room per l'intera app, pertanto rendi RoomDatabase un'unica opzione.
  • Usa il generatore di database di Room per creare il database solo se il database non esiste. In caso contrario, restituisci il database esistente.

Passaggio 1: crea il database

  1. Nel pacchetto database, apri SleepDatabase.kt.
  2. Nel file, crea una classe abstract denominata SleepDatabase che estende RoomDatabase.

    Annota la classe con @Database.
@Database()
abstract class SleepDatabase : RoomDatabase() {}
  1. Vedrai un errore per le entità mancanti e i parametri di versione. L'annotazione @Database richiede diversi argomenti, in modo che Room possa creare il database.
  • Fornisci SleepNight come unico elemento nell'elenco entities.
  • Imposta il version come 1. Ogni volta che cambi lo schema devi aumentare il numero di versione.
  • Imposta exportSchema su false, in modo da non conservare i backup della cronologia delle versioni dello schema.
entities = [SleepNight::class], version = 1, exportSchema = false
  1. Il database deve essere al corrente del DAO. Nel corpo della classe, dichiara un valore astratto che restituisce SleepDatabaseDao. Puoi avere più DAO. 
abstract val sleepDatabaseDao: SleepDatabaseDao
  1. Poi, definisci un oggetto companion. L'oggetto companion consente ai client di accedere ai metodi per la creazione o il recupero del database senza creare un'istanza della classe. L'unico scopo di questa lezione è fornire un database, quindi non è possibile creare un'istanza in modo definitivo.
 companion object {}
  1. All'interno dell'oggetto companion, dichiara una variabile null privata INSTANCE per il database e inizializzala in null. Una volta creata, la variabile INSTANCE conserverà un riferimento al database. In questo modo puoi evitare di aprire ripetutamente le connessioni al database, che è costoso.

Annota INSTANCE con @Volatile. Il valore di una variabile volatile non viene mai memorizzato nella cache e tutte le operazioni di scrittura e lettura vengono eseguite da e verso la memoria principale. In questo modo ci si assicura che il valore di INSTANCE sia sempre aggiornato e che sia uguale per tutti i thread di esecuzione. Ciò significa che le modifiche apportate da un thread a INSTANCE sono immediatamente visibili a tutti gli altri thread e non si verifica una situazione in cui, ad esempio, due thread aggiornano la stessa entità in una cache, causando un problema.

@Volatile
private var INSTANCE: SleepDatabase? = null
  1. Sotto INSTANCE, sempre all'interno dell'oggetto companion, definisci un getInstance()metodo con un parametro Context di cui avrà bisogno il generatore di database. Restituisci un tipo SleepDatabase. Vedrai un errore perché getInstance() non restituisce ancora nulla.
fun getInstance(context: Context): SleepDatabase {}
  1. All'interno di getInstance(), aggiungi un blocco synchronized{}. Passa il passaggio this per poter accedere al contesto.

    Più thread possono richiedere un'istanza di database contemporaneamente, generando due database invece di uno. È probabile che questo problema non si verifichi in questa app di esempio, ma è possibile per un'app più complessa. L'inclusione del codice per inserire il database in synchronized significa che solo un thread di esecuzione alla volta può inserire questo blocco di codice, il che assicura che il database venga inizializzato solo una volta.
synchronized(this) {}
  1. Copia il valore corrente di INSTANCE all'interno del blocco sincronizzato in una variabile locale instance. Questo vale per l'utilizzo di smart Cast, disponibile solo per le variabili locali.
var instance = INSTANCE
  1. All'interno del blocco synchronized, return instance alla fine del blocco synchronized. Ignora l'errore di mancata corrispondenza del tipo di reso; non restituisci mai un valore null una volta terminato.
return instance
  1. Sopra l'istruzione return, aggiungi un'istruzione if per verificare se instance è null, ovvero se non esiste ancora alcun database.
if (instance == null) {}
  1. Se instance è null, utilizza lo strumento per la creazione di database per ottenerlo. Nel corpo dell'istruzione if, richiama Room.databaseBuilder e specifica il contesto passato, la classe di database e un nome per il database, sleep_history_database. Per rimuovere l'errore, dovrai aggiungere una strategia di migrazione e build() nei passaggi seguenti.
instance = Room.databaseBuilder(
                           context.applicationContext,
                           SleepDatabase::class.java,
                           "sleep_history_database")
  1. Aggiungi la strategia di migrazione richiesta al builder. Usa .fallbackToDestructiveMigration().

    In genere, è necessario fornire un oggetto di migrazione con una strategia di migrazione quando cambi lo schema. Un oggetto di migrazione è un oggetto che definisce il modo in cui acquisisci tutte le righe con lo schema precedente e le convertirai in righe nel nuovo schema, in modo che non vengano persi dati. La migrazione non rientra nell'ambito di questo codelab. Una soluzione semplice consiste nell'eliminazione e ricostruzione del database, il che comporta la perdita dei dati.
.fallbackToDestructiveMigration()
  1. Infine, chiama il numero .build().
.build()
  1. Assegna INSTANCE = instance come ultimo passaggio nell'istruzione if. 
INSTANCE = instance
  1. Il tuo codice finale dovrebbe avere il seguente aspetto: 
@Database(entities = [SleepNight::class], version = 1, exportSchema = false)
abstract class SleepDatabase : RoomDatabase() {

   abstract val sleepDatabaseDao: SleepDatabaseDao

   companion object {

       @Volatile
       private var INSTANCE: SleepDatabase? = null

       fun getInstance(context: Context): SleepDatabase {
           synchronized(this) {
               var instance = INSTANCE

               if (instance == null) {
                   instance = Room.databaseBuilder(
                           context.applicationContext,
                           SleepDatabase::class.java,
                           "sleep_history_database"
                   )
                           .fallbackToDestructiveMigration()
                           .build()
                   INSTANCE = instance
               }
               return instance
           }
       }
   }
}
  1. Crea ed esegui il tuo codice.

Ora hai tutti gli elementi fondamentali per lavorare con il tuo database Room. Questo codice viene compilato ed eseguito, ma non è possibile capire se funziona. Pertanto, questo è il momento giusto per aggiungere alcuni test di base.

Passaggio 2: testa il database del database

In questo passaggio, esegui i test forniti per verificare che il database funzioni. In questo modo hai la certezza che il database funzioni prima di crearlo. I test forniti sono di base. Per un'app in produzione, eserciterai tutte le funzioni e le query in tutti i DAO.

L'app iniziale contiene una cartella androidTest. Questa cartella androidTest contiene test delle unità che prevedono la strumentazione di Android, un modo per dichiarare che i test richiedono il framework Android, quindi è necessario eseguirli su un dispositivo fisico o virtuale. Naturalmente, puoi anche creare ed eseguire test delle unità pure che non coinvolgono il framework Android.

  1. In Android Studio, nella cartella androidTest, apri il file SleepDatabaseTest.
  2. Per annullare il commento del codice, seleziona tutto il codice commentato e premi la scorciatoia da tastiera Cmd+/ o Control+/.
  3. Dai un'occhiata al file.

Ecco una rapida esecuzione del codice di test, perché è un altro codice che puoi riutilizzare:

  • SleepDabaseTest è una classe di prova.
  • L'annotazione @RunWith identifica il runner, che è il programma che configura ed esegue i test.
  • Durante la configurazione, la funzione annotata con @Before viene eseguita e crea un SleepDatabase in memoria con SleepDatabaseDao. "In memoria" significa che questo database non viene salvato nel file system e verrà eliminato dopo l'esecuzione dei test.
  • Inoltre, quando crei il database in memoria, il codice chiama un altro metodo specifico di test, allowMainThreadQueries. Per impostazione predefinita, ricevi un messaggio di errore se provi a eseguire query sul thread principale. Questo metodo ti consente di eseguire test sul thread principale, operazione che dovresti eseguire solo durante il test.
  • In un metodo di test annotato con @Test, puoi creare, inserire e recuperare un SleepNight e affermare che sono uguali. Se si verifica un problema, genera un'eccezione. In un test reale, esistevi diversi @Test metodi.
  • Al termine del test, la funzione annotata con @After viene eseguita per chiudere il database.
  1. Fai clic con il pulsante destro del mouse sul file di test nel riquadro Progetto e seleziona Esegui 'SleepDatabaseTest'.
  2. Dopo l'esecuzione dei test, verifica nel riquadro SleepDatabaseTest che tutti i test siano stati superati.

Dato che tutti i test sono stati superati, ora hai diverse informazioni:

  • Il database viene creato correttamente.
  • Puoi inserire un SleepNight nel database.
  • Puoi recuperare SleepNight.
  • SleepNight ha il valore corretto per la qualità.

Progetto Android Studio: TrackMySleep QualityRoomAndTesting

Durante il test di un database, devi esercitarti con tutti i metodi definiti nel DAO. Per completare il test, aggiungi ed esegui test per esercitarti con gli altri metodi DAO.

  • Definisci le tabelle come classi di dati annotate con @Entity. Definisci le proprietà annotate con @ColumnInfo come colonne nelle tabelle.
  • Definisci un oggetto Data Access (DAO) come interfaccia annotata con @Dao. Il DAO mappa le funzioni di Kotlin alle query del database.
  • Utilizza le annotazioni per definire le funzioni di @Insert, @Delete e @Update.
  • Utilizza l'annotazione @Query con una stringa di query SQLite come parametro per qualsiasi altra query.
  • Crea una classe astratta con una funzione getInstance() che restituisca un database.
  • Utilizza i test con strumentazione per verificare che il database e DAO funzionino come previsto. Puoi utilizzare i modelli forniti come modello.

Corso Udacity:

Documentazione per gli sviluppatori Android:

Altra documentazione e articoli:

In questa sezione sono elencati i possibili compiti per gli studenti che lavorano attraverso questo codelab nell'ambito di un corso tenuto da un insegnante. Spetta all'insegnante fare quanto segue:

  • Assegna i compiti, se necessario.
  • Comunica agli studenti come inviare compiti.
  • Valuta i compiti.

Gli insegnanti possono utilizzare i suggerimenti solo quanto e come vogliono e dovrebbero assegnare i compiti che ritengono appropriati.

Se stai lavorando da solo a questo codelab, puoi utilizzare questi compiti per mettere alla prova le tue conoscenze.

Rispondi a queste domande

Domanda 1

Come indichi che una classe rappresenta un'entità da archiviare in un database Room?

  • Fai in modo che la classe si estenda su DatabaseEntity.
  • Annota la classe con @Entity.
  • Annota la classe con @Database.
  • Fai in modo che la classe estenda RoomEntity e annota la classe con @Room.

Domanda 2

L'oggetto DAO (Data Access Object) è un'interfaccia che Room utilizza per mappare le funzioni Kotlin alle query del database.

Come fai a indicare che un'interfaccia rappresenta un DAO per un database Room?

  • Fai estendere l'interfaccia RoomDAO.
  • Rendi l'interfaccia EntityDao estesa, quindi implementa il metodo DaoConnection().
  • Annota l'interfaccia con @Dao.
  • Annota l'interfaccia con @RoomConnection.

Domanda 3

Quali delle seguenti affermazioni sul database Room sono vere? Scegli tutte le risposte pertinenti.

  • Puoi definire tabelle per un database Room come classi di dati annotate.
  • Se restituisci LiveData da una query, Room manterrà aggiornato il LiveData in caso di modifiche a LiveData.
  • Ogni database Room deve avere un solo DAO.
  • Per identificare una classe come database Room, impostala come sottoclasse di RoomDatabase e aggiungi una nota con @Database.

Domanda 4

Quale delle seguenti annotazioni puoi utilizzare nell'interfaccia di @Dao? Scegli tutte le risposte pertinenti.

  • @Get
  • @Update
  • @Insert
  • @Query

Domanda 5

Come puoi verificare che il database funzioni? Seleziona tutte le risposte pertinenti.

  • Scrivere test con strumentazione.
  • Continua a scrivere ed eseguire l'app fino a quando non visualizza i dati.
  • Sostituisci le chiamate ai metodi nell'interfaccia DAO con chiamate a metodi equivalenti nella classe Entity.
  • Esegui la funzione verifyDatabase() fornita dalla libreria Room.

Inizia alla lezione successiva: 6.2 Coroutines e Room

Per i link ad altri codelab in questo corso, consulta la pagina di destinazione di Android Kotlin Fundamentals.