Android Kotlin Fundamentals 06.1: Create a Room database

Questo codelab fa parte del corso Android Kotlin Fundamentals. Per ottenere il massimo valore da questo corso, ti consigliamo di seguire le codelab in sequenza. Tutti i codelab del corso sono elencati nella pagina di destinazione dei codelab Android Kotlin Fundamentals.

Introduzione

La maggior parte delle app ha dati che devono essere conservati, anche dopo che l'utente chiude l'app. Ad esempio, l'app potrebbe memorizzare una playlist, un inventario di elementi di gioco, registri di spese e entrate, un catalogo di costellazioni o dati sul sonno nel tempo. In genere, si utilizza un database per archiviare i dati persistenti.

Room è una libreria di database che fa parte di Jetpack per Android. Room si occupa di molte delle attività di configurazione di un database e consente alla tua app di interagire con il database utilizzando normali chiamate di funzioni. Room è un livello di astrazione sopra 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 come si inserisce il database Room nell'architettura complessiva consigliata in questo corso.

Cosa devi già sapere

Devi avere familiarità con:

  • Creare un'interfaccia utente (UI) di base per un'app per Android
  • Utilizzo di attività, frammenti e visualizzazioni.
  • Spostarsi tra i fragment e utilizzare Safe Args (un plug-in Gradle) per passare dati tra i fragment.
  • Visualizza modelli, fabbriche di modelli di visualizzazione e LiveData e i relativi osservatori. Questi argomenti relativi ai componenti dell'architettura sono trattati in un codelab precedente di questo corso.
  • Una conoscenza di base dei database SQL e del linguaggio SQLite. Consulta la guida introduttiva a SQLite per una panoramica rapida o un ripasso.

Obiettivi didattici

  • Come creare e interagire con un database Room per rendere persistenti i dati.
  • Come creare una classe di dati che definisce una tabella nel database.
  • Come utilizzare un oggetto di accesso ai dati (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 sul sonno notturno.
  • Testa il database utilizzando i test forniti.

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

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

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

La seconda schermata, mostrata a destra, serve per selezionare una valutazione della qualità del sonno. Nell'app, la valutazione è rappresentata numericamente. A scopo di sviluppo, l'app mostra sia le icone delle facce sia i relativi 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. Viene registrata l'ora di inizio e visualizzata. Il pulsante Avvia è disattivato e il pulsante Interrompi è attivato.
  • L'utente tocca il pulsante Interrompi. Viene registrata l'ora di fine e si apre la schermata della qualità del sonno.
  • L'utente seleziona un'icona della qualità del sonno. La schermata si chiude e la schermata di monitoraggio mostra l'ora di fine del sonno e la qualità del sonno. Il pulsante Interrompi è disattivato e il pulsante Avvia è attivato. L'app è pronta per un'altra notte.
  • Il pulsante Cancella è attivo ogni volta che sono presenti dati nel database. Quando l'utente tocca il pulsante Cancella, tutti i suoi dati vengono cancellati senza possibilità di recupero. Non viene visualizzato alcun messaggio di conferma.

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

  • Controller UI
  • Visualizza modello e LiveData
  • Un database delle stanze

Passaggio 1: scarica ed esegui l'app iniziale

  1. Scarica l'app TrackMySleepQuality-Starter da GitHub.
  2. Crea ed esegui l'app. L'app mostra l'interfaccia utente per il fragment SleepTrackerFragment, ma nessun dato. I pulsanti non rispondono ai tocchi.

Passaggio 2: ispeziona l'app iniziale

  1. Dai un'occhiata ai file Gradle:
  • Il file Gradle del progetto
    : nel file build.gradle a livello di progetto, nota le variabili che specificano le versioni della libreria. Le versioni utilizzate nell'app iniziale funzionano bene insieme e con questa app. Al termine di questo codelab, Android Studio potrebbe chiederti di aggiornare alcune versioni. Spetta a te decidere se eseguire l'aggiornamento o mantenere le versioni presenti nell'app. Se riscontri errori di compilazione "strani", prova a utilizzare la combinazione di versioni della libreria utilizzata dall'app della soluzione finale.
  • Il file Gradle del modulo. Nota le dipendenze fornite per tutte le librerie Android Jetpack, inclusa 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 in cui aggiungerai il codice nel corso di 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 relativa fabbrica per ogni schermata.
  1. Dai un'occhiata al Util.kt file, che contiene funzioni per visualizzare i dati sulla qualità del sonno. Alcuni codici sono commentati perché fanno riferimento a un modello di visualizzazione che creerai 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 sono rappresentati nelle classi di dati e vi si accede e vengono modificati utilizzando chiamate di funzioni. Tuttavia, nel mondo dei database, hai bisogno di 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 quella classe rappresenta una riga nella tabella. Ogni proprietà definisce una colonna. Nella tua app, l'entità 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 oppure una richiesta di esecuzione di un'azione sui dati. Le query più comuni riguardano l'ottenimento, l'inserimento e l'aggiornamento delle entità. Ad esempio, potresti eseguire una query su tutte le notti di sonno registrate, ordinate per ora di inizio.

Room fa tutto il lavoro difficile per te per passare dalle classi di dati Kotlin alle entità che possono essere archiviate nelle tabelle SQLite e dalle dichiarazioni di funzioni alle query SQL.

Devi definire ogni entità come classe di dati annotata e le interazioni come interfaccia annotata, un data access object (DAO). Room utilizza queste classi annotate per creare tabelle nel database e 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à.

Inoltre, ti serve un ID per identificare in modo univoco la notte.

  1. Nel pacchetto database, trova e apri il file SleepNight.kt.
  2. Crea la classe di dati SleepNight con parametri per un ID, un orario di inizio (in millisecondi), un orario di fine (in millisecondi) e una valutazione numerica della qualità del sonno.
  • Devi inizializzare sleepQuality, quindi impostalo su -1, indicando che non sono stati raccolti dati di qualità.
  • Devi anche inizializzare l'ora di fine. Impostalo sull'ora di inizio per indicare che non è ancora stata registrata un'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 di 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 primaria, annota la proprietà nightId con @PrimaryKey. Imposta il parametro autoGenerate su true in modo che Room generi l'ID per ogni entità. In questo modo, l'ID per ogni notte è univoco. 
@PrimaryKey(autoGenerate = true)
var nightId: Long = 0L,...
  1. Aggiungi un'annotazione alle 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 codice per assicurarti che non contenga errori.

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

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

Pensa a un DAO come a una definizione di un'interfaccia personalizzata per accedere al tuo database.

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

Inoltre, durante la creazione delle query in Android Studio, il compilatore controlla la presenza di errori di sintassi.

Per il database del monitoraggio del sonno delle notti di sonno, devi essere in grado di:

  • Inserisci le nuove notti.
  • Aggiorna una notte esistente per aggiornare l'ora di fine e una valutazione della qualità.
  • Ottieni una notte specifica in base alla chiave.
  • Ottieni tutte le notti, in modo da poterle visualizzare.
  • Visualizzare la notte più recente.
  • Elimina tutte le voci nel database.

Passaggio 1: crea il DAO SleepDatabase

  1. Nel pacchetto database, apri SleepDatabaseDao.kt.
  2. Nota che interface SleepDatabaseDao è annotato con @Dao. Tutte le DAO devono essere annotate con la parola chiave @Dao. 
@Dao
interface SleepDatabaseDao {}
  1. All'interno del corpo dell'interfaccia, aggiungi un'annotazione @Insert. Sotto @Insert, aggiungi una funzione insert() che accetta un'istanza della classe Entity SleepNight come argomento.

    È tutto. Room genererà tutto il codice necessario per inserire SleepNight nel database. Quando chiami insert() dal 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 SleepNight. L'entità aggiornata è quella che ha la stessa chiave di quella passata. 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 accetta un argomento Long key e restituisce un valore SleepNight che può essere nullo. Visualizzerai 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. Crea un String che sia una query SQLite.
  • Seleziona tutte le colonne da daily_sleep_quality_table
  • WHERE nightId corrisponde all'argomento :key.

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

    L'annotazione @Delete elimina un elemento e puoi utilizzare @Delete e fornire un elenco di notti da eliminare. Lo svantaggio è che devi recuperare o sapere cosa contiene la tabella. L'annotazione @Delete è ideale per eliminare voci specifiche, ma non è efficiente per cancellare tutte le voci di una tabella.
@Query("DELETE FROM daily_sleep_quality_table")
fun clear()
  1. Aggiungi un @Query con una funzione getTonight(). Rendi SleepNight restituito da getTonight() annullabile, 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 ottenere "stasera" dal database, scrivi una query SQLite che restituisca il primo elemento di un elenco di risultati ordinati per 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 @Query con una funzione getAllNights():
  • Fai in modo che la query SQLite restituisca tutte le colonne di daily_sleep_quality_table, ordinate in ordine decrescente.
  • Fai in modo che getAllNights() restituisca un elenco di entità SleepNight come LiveData. Room mantiene aggiornato questo LiveData per te, il che significa che devi recuperare i dati esplicitamente 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 vedrai modifiche visibili, esegui l'app per assicurarti che non contenga errori.

In questa attività, crei un database Room che utilizza Entity e DAO che hai creato nell'attività precedente.

Devi creare una classe astratta di contenitore del database annotata con @Database. Questa classe ha un metodo che crea un'istanza del database se non esiste oppure restituisce un riferimento a un database esistente.

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

  • Crea un corso public abstract che extends RoomDatabase. Questa classe funge da contenitore del database. La classe è astratta perché Room crea l'implementazione per te.
  • 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 un metodo o una proprietà astratta che restituisce un SleepDatabaseDao. Room genererà il corpo per te.
  • Ti serve una sola istanza del database Room per l'intera app, quindi crea un singleton per RoomDatabase.
  • Utilizza lo strumento di creazione di database di Room per creare il database solo se 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 chiamata SleepDatabase che estende RoomDatabase.

    Annota la classe con @Database.
@Database()
abstract class SleepDatabase : RoomDatabase() {}
  1. Visualizzerai un errore per le entità e i parametri di versione mancanti. L'annotazione @Database richiede diversi argomenti, in modo che Room possa creare il database.
  • Fornisci SleepNight come unico elemento con l'elenco di entities.
  • Imposta version come 1. Ogni volta che modifichi lo schema, devi aumentare il numero di versione.
  • Imposta exportSchema su false per non conservare i backup della cronologia delle versioni dello schema.
entities = [SleepNight::class], version = 1, exportSchema = false
  1. Il database deve conoscere la DAO. All'interno del corpo della classe, dichiara un valore astratto che restituisce SleepDatabaseDao. Puoi avere più DAO. 
abstract val sleepDatabaseDao: SleepDatabaseDao
  1. Sotto, definisci un oggetto companion. L'oggetto complementare consente ai client di accedere ai metodi per creare o ottenere il database senza creare un'istanza della classe. Poiché l'unico scopo di questa classe è fornire un database, non c'è motivo di istanziarla.
 companion object {}
  1. All'interno dell'oggetto companion, dichiara una variabile privata nullable INSTANCE per il database e inizializzala su null. La variabile INSTANCE manterrà un riferimento al database una volta creato. In questo modo, eviti di aprire ripetutamente connessioni al database, il che è costoso.

Annota INSTANCE con @Volatile. Il valore di una variabile volatile non verrà mai memorizzato nella cache e tutte le scritture e le letture verranno eseguite nella memoria principale. In questo modo, il valore di INSTANCE è sempre aggiornato e 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, il che creerebbe un problema.

@Volatile
private var INSTANCE: SleepDatabase? = null
  1. Sotto INSTANCE, ancora all'interno dell'oggetto companion, definisci un metodo getInstance() con un parametro Context necessario al generatore di database. Restituisci un tipo SleepDatabase. Visualizzerai un errore perché getInstance() non restituisce ancora nulla.
fun getInstance(context: Context): SleepDatabase {}
  1. All'interno di getInstance(), aggiungi un blocco synchronized{}. Passa this in modo da poter accedere al contesto.

    Più thread possono potenzialmente richiedere un'istanza di database contemporaneamente, il che comporta la creazione di due database anziché uno. È improbabile che questo problema si verifichi in questa app di esempio, ma è possibile per un'app più complessa. Il wrapping del codice per inserire il database in synchronized significa che solo un thread di esecuzione alla volta può accedere a questo blocco di codice, il che garantisce che il database venga inizializzato una sola volta.
synchronized(this) {}
  1. All'interno del blocco sincronizzato, copia il valore corrente di INSTANCE in una variabile locale instance. Questo per sfruttare il cast intelligente, 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 restituito; una volta terminato, non restituirai mai un valore nullo.
return instance
  1. Sopra l'istruzione return, aggiungi un'istruzione if per verificare se instance è null, ovvero se non esiste ancora un database.
if (instance == null) {}
  1. Se instance è null, utilizza lo strumento per la creazione di database per ottenere un database. Nel corpo dell'istruzione if, richiama Room.databaseBuilder e fornisci il contesto che hai passato, la classe del database e un nome per il database, sleep_history_database. Per rimuovere l'errore, dovrai aggiungere una strategia di migrazione e build() nei passaggi successivi.
instance = Room.databaseBuilder(
                           context.applicationContext,
                           SleepDatabase::class.java,
                           "sleep_history_database")
  1. Aggiungi la strategia di migrazione richiesta al builder. Utilizza .fallbackToDestructiveMigration().

    Normalmente, dovresti fornire un oggetto di migrazione con una strategia di migrazione per quando lo schema cambia. Un oggetto di migrazione è un oggetto che definisce come prendere tutte le righe con il vecchio schema e convertirle in righe nel nuovo schema, in modo che non vengano persi dati. La migrazione non rientra nell'ambito di questo codelab. Una soluzione semplice è distruggere e ricreare il database, il che significa che i dati vengono persi.
.fallbackToDestructiveMigration()
  1. Infine, chiama il numero .build().
.build()
  1. Assegna INSTANCE = instance come passaggio finale all'interno dell'istruzione if. 
INSTANCE = instance
  1. Il 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 codice.

Ora hai tutti i componenti di base per lavorare con il tuo database Room. Questo codice viene compilato ed eseguito, ma non hai modo di sapere se funziona davvero. Quindi, è il momento giusto per aggiungere alcuni test di base.

Passaggio 2: prova SleepDatabase

In questo passaggio, esegui i test forniti per verificare che il database funzioni. In questo modo, ti assicuri che il database funzioni prima di utilizzarlo. I test forniti sono di base. Per un'app di produzione, devi esercitare tutte le funzioni e le query in tutti i DAO.

L'app iniziale contiene una cartella androidTest. Questa cartella androidTest contiene unit test che coinvolgono l'instrumentazione Android, un modo elegante per dire che i test hanno bisogno del framework Android, quindi devi eseguirli su un dispositivo fisico o virtuale. Naturalmente, puoi anche creare ed eseguire test delle unità puri che non coinvolgono il framework Android.

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

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

  • SleepDabaseTest è un corso di prova.
  • L'annotazione @RunWith identifica il test runner, ovvero il programma che configura ed esegue i test.
  • Durante la configurazione, viene eseguita la funzione annotata con @Before e viene creato 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, durante la creazione del database in memoria, il codice chiama un altro metodo specifico per i test, allowMainThreadQueries. Per impostazione predefinita, ricevi un errore se provi a eseguire query sul thread principale. Questo metodo consente di eseguire test sul thread principale, cosa che dovresti fare solo durante i test.
  • In un metodo di test annotato con @Test, crei, inserisci e recuperi un SleepNight e affermi che sono uguali. Se qualcosa va storto, genera un'eccezione. In un test reale, avresti più metodi di @Test .
  • Al termine del test, la funzione annotata con @After viene eseguita per chiudere il database.
  1. Fai clic con il tasto 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.

Poiché tutti i test sono stati superati, ora sai diverse cose:

  • 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: TrackMySleepQualityRoomAndTesting

Quando testi un database, devi esercitare tutti i metodi definiti nel DAO. Per completare i test, aggiungi ed esegui test per esercitare 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 Data Access Object (DAO) come interfaccia annotata con @Dao. Il DAO mappa le funzioni Kotlin alle query del database.
  • Utilizza le annotazioni per definire le funzioni @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 restituisce un database.
  • Utilizza test strumentati per verificare che il database e il DAO funzionino come previsto. Puoi utilizzare i test forniti come modello.

Corso Udacity:

Documentazione per sviluppatori Android:

Altri documenti e articoli:

Questa sezione elenca i possibili compiti a casa per gli studenti che seguono questo codelab nell'ambito di un corso guidato da un insegnante. Spetta all'insegnante:

  • Assegna i compiti, se richiesto.
  • Comunica agli studenti come inviare i compiti.
  • Valuta i compiti a casa.

Gli insegnanti possono utilizzare questi suggerimenti nella misura che ritengono opportuna e sono liberi di assegnare qualsiasi altro compito a casa che ritengono appropriato.

Se stai seguendo questo codelab in autonomia, sentiti libero di utilizzare questi compiti per casa per mettere alla prova le tue conoscenze.

Rispondi a queste domande

Domanda 1

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

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

Domanda 2

L'oggetto di accesso ai dati (DAO) è un'interfaccia che Room utilizza per mappare le funzioni Kotlin alle query del database.

Come si indica che un'interfaccia rappresenta un DAO per un database Room?

  • Fai in modo che l'interfaccia si estenda RoomDAO.
  • Fai in modo che l'interfaccia estenda EntityDao, poi 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? Seleziona tutte le risposte pertinenti.

  • Puoi definire le tabelle per un database Room come classi di dati annotati.
  • Se restituisci LiveData da una query, Room manterrà aggiornato LiveData per te se LiveData cambia.
  • Ogni database Room deve avere una sola DAO.
  • Per identificare una classe come database Room, rendila una sottoclasse di RoomDatabase e annotala con @Database.

Domanda 4

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

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

Domanda 5

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

  • Scrivi test strumentati.
  • Continua a scrivere ed eseguire l'app finché non vengono visualizzati 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 la lezione successiva: 6.2 Coroutine e Room

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