Aspectos básicos de Kotlin para Android 06.1: Cómo crear una base de datos de Room

Este codelab es parte del curso Conceptos básicos de Kotlin para Android. Aprovecharás al máximo este curso si trabajas con los codelabs de forma secuencial. Todos los codelabs del curso se enumeran en la página de destino de los codelabs de Android Kotlin Fundamentals.

Introducción

La mayoría de las apps tienen datos que deben conservarse, incluso después de que el usuario cierra la app. Por ejemplo, la app podría almacenar una playlist, un inventario de elementos del juego, registros de gastos e ingresos, un catálogo de constelaciones o datos de sueño a lo largo del tiempo. Por lo general, se usa una base de datos para almacenar datos persistentes.

Room es una biblioteca de bases de datos que forma parte de Android Jetpack. Room se encarga de muchas de las tareas de implementación y configuración de una base de datos, y permite que tu app interactúe con la base de datos usando llamadas a funciones comunes. En segundo plano, Room es una capa de abstracción sobre una base de datos SQLite. La terminología de Room y la sintaxis de las consultas más complejas siguen el modelo de SQLite.

En la siguiente imagen, se puede apreciar cómo la base de datos Room se ajusta a la arquitectura general recomendada en este curso.

Conocimientos que ya deberías tener

Debes estar familiarizado con lo siguiente:

  • Cómo compilar una interfaz de usuario (IU) básica para una app para Android
  • Usar actividades, fragmentos y vistas
  • Navegar entre fragmentos y usar Safe Args (un complemento de Gradle) para pasar datos entre fragmentos
  • Modelos de vista, fábricas de modelos de vista, LiveData y sus observadores Estos temas sobre los componentes de arquitectura se explican en un codelab anterior de este curso.
  • Tener conocimientos básicos de las bases de datos SQL y el lenguaje SQLite Consulta la Guía de inicio rápido de SQLite para obtener una descripción general o un repaso rápidos.

Qué aprenderás

  • Cómo crear una base de datos Room y cómo interactuar con ella para conservar datos
  • Cómo crear una clase de datos que defina una tabla en la base de datos
  • Cómo usar un objeto de acceso a datos (DAO) para asignar funciones de Kotlin a consultas de SQL
  • Cómo probar si tu base de datos funciona

Actividades

  • Crea una base de datos de Room con una interfaz para los datos de sueño nocturno.
  • Prueba la base de datos con las pruebas proporcionadas.

En este codelab, compilarás la parte de la base de datos de una app que hace un seguimiento de la calidad del sueño. La app usa una base de datos para almacenar los datos de sueño a lo largo del tiempo.

La app tiene dos pantallas, representadas por fragmentos, como se muestra en la siguiente figura.

La primera pantalla, que se muestra a la izquierda, tiene botones para iniciar y detener el seguimiento. En la pantalla, se muestran todos los datos de sueño del usuario. El botón Borrar borra de forma permanente todos los datos que la app recopiló del usuario.

La segunda pantalla, que se muestra a la derecha, es para seleccionar una calificación de la calidad del sueño. En la app, la calificación se representa de forma numérica. Para fines de desarrollo, la app muestra los íconos de caras y sus equivalentes numéricos.

El flujo del usuario es el siguiente:

  • El usuario abre la app y se muestra la pantalla de monitoreo del sueño.
  • El usuario presiona el botón Start. Esto registra la hora de inicio y la muestra. El botón Start está inhabilitado y el botón Stop está habilitado.
  • El usuario presiona el botón Detener. Esto registra la hora de finalización y abre la pantalla de calidad del sueño.
  • El usuario selecciona un ícono de calidad del sueño. La pantalla se cierra y la pantalla de monitoreo muestra la hora de finalización del sueño y la calidad del sueño. El botón Detener está inhabilitado y el botón Iniciar está habilitado. La app está lista para otra noche.
  • El botón Borrar se habilita siempre que haya datos en la base de datos. Cuando el usuario presiona el botón Borrar, se borran todos sus datos sin recurso, no aparece el mensaje "¿Seguro?".

Esta app usa una arquitectura simplificada, como se muestra a continuación en el contexto de la arquitectura completa. La app solo usa los siguientes componentes:

  • Controlador de IU
  • Ver el modelo y LiveData
  • Una base de datos de Room

Paso 1: Descarga y ejecuta la app de inicio

  1. Descarga la app TrackMySleepQuality-Starter de GitHub.
  2. Compila y ejecuta la app. La app muestra la IU del fragmento SleepTrackerFragment, pero no muestra datos. Los botones no responden cuando los presionas.

Paso 2: Inspecciona la app de partida

  1. Echa un vistazo a los archivos de Gradle:
  • El archivo Gradle del proyecto
    En el archivo build.gradle a nivel del proyecto, observa las variables que especifican las versiones de la biblioteca. Las versiones que se usan en la app inicial funcionan bien juntas y con esta app. Cuando termines este codelab, es posible que Android Studio te solicite que actualices algunas de las versiones. Depende de ti si quieres actualizar o quedarte con las versiones que están en la app. Si te encuentras con errores de compilación "extraños", intenta usar la combinación de versiones de biblioteca que usa la app de solución final.
  • El archivo Gradle del módulo. Observa las dependencias proporcionadas para todas las bibliotecas de Android Jetpack, incluidas Room y las dependencias para corrutinas.
  1. Observa los paquetes y la IU. La app está estructurada por funcionalidad. El paquete contiene archivos de marcadores de posición en los que agregarás código a lo largo de esta serie de codelabs.
  • El paquete database, para todo el código relacionado con la base de datos Room
  • Los paquetes sleepquality y sleeptracker contienen el fragmento, el modelo de vista y la fábrica del modelo de vista para cada pantalla.
  1. Echa un vistazo al archivo Util.kt, que contiene funciones para ayudar a mostrar los datos de calidad del sueño. Parte del código está comentado porque hace referencia a un modelo de vista que crearás más adelante.
  2. Echa un vistazo a la carpeta androidTest (SleepDatabaseTest.kt). Usarás esta prueba para verificar que la base de datos funcione según lo previsto.

En Android, los datos se representan en clases de datos, y se accede a ellos y se modifican con llamadas a funciones. Sin embargo, en el mundo de las bases de datos, necesitas entidades y consultas.

  • Una entidad representa un objeto o concepto, y sus propiedades, para almacenar contenido en la base de datos. Una clase de entidad define una tabla, y cada instancia de esa clase representa una fila en la tabla. Cada propiedad define una columna. En tu app, la entidad conservará información sobre una noche de sueño.
  • Una consulta es una solicitud de datos o información de una tabla de base de datos o una combinación de tablas, o bien una solicitud para realizar una acción en los datos. Las consultas comunes son para obtener, insertar y actualizar entidades. Por ejemplo, podrías consultar todas las noches de sueño registradas, ordenadas por hora de inicio.

Room hace todo el trabajo difícil para que pases de las clases de datos de Kotlin a las entidades que se pueden almacenar en tablas de SQLite y de las declaraciones de funciones a las consultas de SQL.

Debes definir cada entidad como una clase de datos anotada y las interacciones como una interfaz anotada, un objeto de acceso a datos (DAO). Room usa estas clases anotadas para crear tablas en la base de datos y consultas que actúan en la base de datos.

Paso 1: Crea la entidad SleepNight

En esta tarea, definirás una noche de sueño como una clase de datos anotada.

Para una noche de sueño, debes registrar la hora de inicio, la hora de finalización y una calificación de calidad.

Además, necesitas un ID para identificar de forma única la noche.

  1. En el paquete database, busca y abre el archivo SleepNight.kt.
  2. Crea la clase de datos SleepNight con parámetros para un ID, una hora de inicio (en milisegundos), una hora de finalización (en milisegundos) y una calificación numérica de la calidad del sueño.
  • Debes inicializar sleepQuality, por lo que debes establecerlo en -1, lo que indica que no se recopilaron datos de calidad.
  • También debes inicializar la hora de finalización. Establécelo en la hora de inicio para indicar que aún no se registró ninguna hora de finalización. 
data class SleepNight(
       var nightId: Long = 0L,
       val startTimeMilli: Long = System.currentTimeMillis(),
       var endTimeMilli: Long = startTimeMilli,
       var sleepQuality: Int = -1
)
  1. Antes de la declaración de la clase, anota la clase de datos con @Entity. Asígnale el nombre daily_sleep_quality_table a la tabla. El argumento para tableName es opcional, pero se recomienda. Puedes buscar otros argumentos en la documentación.

    Si se te solicita, importa Entity y todas las demás anotaciones de la biblioteca androidx.
@Entity(tableName = "daily_sleep_quality_table")
data class SleepNight(...)
  1. Para identificar nightId como la clave primaria, anota la propiedad nightId con @PrimaryKey. Establece el parámetro autoGenerate en true para que Room genere el ID de cada entidad. Esto garantiza que el ID de cada noche sea único. 
@PrimaryKey(autoGenerate = true)
var nightId: Long = 0L,...
  1. Anota las propiedades restantes con @ColumnInfo. Personaliza los nombres de las propiedades con los parámetros que se muestran a continuación. 
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. Compila y ejecuta tu código para asegurarte de que no tenga errores.

En esta tarea, definirás un objeto de acceso a datos (DAO). En Android, el DAO proporciona métodos convenientes para insertar, borrar y actualizar la base de datos.

Cuando usas una base de datos Room, la consultas definiendo y llamando a funciones de Kotlin en tu código. Estas funciones de Kotlin se asignan a consultas de SQL. Defines esas asignaciones en un DAO con anotaciones, y Room crea el código necesario.

Considera que un DAO define una interfaz personalizada para acceder a tu base de datos.

Para las operaciones de base de datos comunes, la biblioteca Room proporciona anotaciones de conveniencia, como @Insert, @Delete y @Update. Para todo lo demás, se encuentra la anotación @Query. Puedes escribir cualquier consulta que sea compatible con SQLite.

Como beneficio adicional, a medida que creas tus consultas en Android Studio, el compilador comprueba si las consultas de SQL tienen errores de sintaxis.

En el caso de la base de datos del dispositivo de monitoreo del sueño de las noches de sueño, debes poder hacer lo siguiente:

  • Insertar noches nuevas
  • Actualiza una noche existente para actualizar la hora de finalización y la calificación de calidad.
  • Obtener una noche específica según su clave
  • Obtener todas las noches para que puedas mostrarlas
  • Obtén la noche más reciente.
  • Borrar todas las entradas de la base de datos

Paso 1: Crea el DAO de SleepDatabase

  1. En el paquete database, abre SleepDatabaseDao.kt.
  2. Ten en cuenta que interface SleepDatabaseDao tiene anotaciones con @Dao. Todos los DAO deben anotarse con la palabra clave @Dao. 
@Dao
interface SleepDatabaseDao {}
  1. Dentro del cuerpo de la interfaz, agrega una anotación @Insert. Debajo de @Insert, agrega una función insert() que tome una instancia del SleepNight de la clase Entity como su argumento.

    Eso es todo. Room generará todo el código necesario para insertar SleepNight en la base de datos. Cuando llamas a insert() desde tu código Kotlin, Room ejecuta una consulta de SQL para insertar la entidad en la base de datos. (Nota: Puedes llamar a la función como desees).
@Insert
fun insert(night: SleepNight)
  1. Agrega una anotación @Update con una función update() para un SleepNight. La entidad que se actualiza es la que tiene la misma clave que la que se pasa. Puedes actualizar algunas o todas las demás propiedades de la entidad.
@Update
fun update(night: SleepNight)

No hay ninguna anotación de conveniencia para la funcionalidad restante, por lo que debes usar la anotación @Query y proporcionar consultas de SQLite.

  1. Agrega una anotación @Query con una función get() que tome un argumento Long key y muestre un SleepNight anulable. Verás un error por un parámetro faltante.
@Query
fun get(key: Long): SleepNight?
  1. La consulta se proporciona como un parámetro de cadena a la anotación. Agrega un parámetro a @Query. Haz que sea un String que sea una consulta de SQLite.
  • Selecciona todas las columnas de daily_sleep_quality_table.
  • WHERE (nightId) coincide con el argumento :key.

    Observa el :key. Usa la notación de dos puntos en la consulta para hacer referencia a argumentos en la función.
("SELECT * from daily_sleep_quality_table WHERE nightId = :key")
  1. Agrega otro @Query con una función clear() y una consulta de SQLite para DELETE todo desde el daily_sleep_quality_table. Esta consulta no borra la tabla en sí.

    La anotación @Delete borra un elemento, y puedes usar @Delete y proporcionar una lista de noches para borrar. La desventaja es que necesitas recuperar o saber qué hay en la tabla. La anotación @Delete es ideal para borrar entradas específicas, pero no es eficiente para borrar todas las entradas de una tabla.
@Query("DELETE FROM daily_sleep_quality_table")
fun clear()
  1. Agrega una @Query con una función getTonight(). Haz que el SleepNight que muestra getTonight() sea anulable para que la función pueda controlar el caso en el que la tabla esté vacía. (La tabla está vacía al principio y después de que se borran los datos).

    Para obtener "esta noche" de la base de datos, escribe una consulta de SQLite que devuelva el primer elemento de una lista de resultados ordenados por nightId en orden descendente. Usa LIMIT 1 para devolver solo un elemento.
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC LIMIT 1")
fun getTonight(): SleepNight?
  1. Agrega una @Query con una función getAllNights():
  • Haz que la consulta de SQLite muestre todas las columnas de daily_sleep_quality_table, ordenadas de forma descendente.
  • Haz que getAllNights() muestre una lista de entidades SleepNight como LiveData. Room mantiene este LiveData actualizado por ti, lo que significa que solo necesitas obtener los datos de forma explícita una vez.
  • Es posible que debas importar LiveData de androidx.lifecycle.LiveData.
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC")
fun getAllNights(): LiveData<List<SleepNight>>
  1. Si bien no notarás ningún cambio visible, ejecuta la app para asegurarte de que no tenga errores.

En esta tarea, crearás una base de datos Room que usa Entity y el DAO que creaste en la tarea anterior.

Debes crear una clase abstracta de contenedor de la base de datos, anotada con @Database. Esta clase tiene un método que crea una instancia de la base de datos si no existe, o bien devuelve una referencia a una base de datos existente.

Obtener una base de datos Room es un poco complicado, por lo que aquí se muestra el proceso general antes de comenzar con el código:

  • Crea una clase public abstract que extends RoomDatabase. Esta clase actuará como un contenedor de la base de datos. La clase es abstracta porque Room crea la implementación por ti.
  • Anota la clase con @Database. En los argumentos, declara las entidades para la base de datos y establece el número de versión.
  • Dentro de un objeto companion, define un método o una propiedad abstractos que devuelvan un SleepDatabaseDao. Room generará el cuerpo del mensaje por ti.
  • Solo necesitas una instancia de la base de datos Room para toda la app, así que haz que RoomDatabase sea un singleton.
  • Usa el compilador de bases de datos de Room para crear la base de datos solo si no existe. De lo contrario, muestra la base de datos existente.

Paso 1: Crea la base de datos

  1. En el paquete database, abre SleepDatabase.kt.
  2. En el archivo, crea una clase abstract llamada SleepDatabase que extienda RoomDatabase.

    Anota la clase con @Database.
@Database()
abstract class SleepDatabase : RoomDatabase() {}
  1. Verás un error por falta de parámetros de entidades y versiones. La anotación @Database requiere varios argumentos para que Room pueda compilar la base de datos.
  • Proporciona SleepNight como el único elemento con la lista de entities.
  • Establece version como 1. Cada vez que cambies el esquema, deberás aumentar el número de versión.
  • Establece exportSchema como false para que no se conserven las copias de seguridad del historial de versiones de esquemas.
entities = [SleepNight::class], version = 1, exportSchema = false
  1. La base de datos necesita saber sobre el DAO. Dentro del cuerpo de la clase, declara un valor abstracto que muestre el SleepDatabaseDao. Puedes tener varios DAO. 
abstract val sleepDatabaseDao: SleepDatabaseDao
  1. Debajo de eso, define un objeto companion. El objeto complementario permite que los clientes accedan a los métodos para crear u obtener la base de datos sin crear una instancia de la clase. Dado que el único propósito de esta clase es proporcionar una base de datos, no hay motivos para instanciarla.
 companion object {}
  1. Dentro del objeto companion, declara una variable anulable privada INSTANCE para la base de datos y, luego, inicializala en null. La variable INSTANCE mantendrá una referencia a la base de datos, una vez que se cree una. Esto te ayuda a evitar abrir conexiones a la base de datos de forma repetida, lo que resulta costoso.

Anota INSTANCE con @Volatile. El valor de una variable volátil nunca se almacenará en caché, y todas las operaciones de escritura y lectura se realizarán desde y hacia la memoria principal. Esto ayuda a garantizar que el valor de INSTANCE esté siempre actualizado y sea el mismo para todos los subprocesos de ejecución. Esto significa que los cambios realizados por un subproceso en INSTANCE son visibles de inmediato para todos los demás subprocesos, y no se produce una situación en la que, por ejemplo, dos subprocesos actualizan la misma entidad en una caché, lo que generaría un problema.

@Volatile
private var INSTANCE: SleepDatabase? = null
  1. Debajo de INSTANCE, mientras estás dentro del objeto companion, define un método getInstance() con un parámetro Context que necesite el compilador de bases de datos. Muestra un tipo SleepDatabase. Verás un error porque getInstance() todavía no muestra nada.
fun getInstance(context: Context): SleepDatabase {}
  1. Dentro de getInstance(), agrega un bloque synchronized{}. Pasa this para que puedas acceder al contexto.

    Es posible que varios subprocesos soliciten una instancia de base de datos al mismo tiempo, lo que genera dos bases de datos en lugar de una. Es poco probable que este problema ocurra en esta app de ejemplo, pero es posible que suceda en una app más compleja. Unir el código para obtener la base de datos en synchronized significa que solo un subproceso de ejecución a la vez puede ingresar este bloque de código, lo que garantiza que la base de datos solo se inicialice una vez.
synchronized(this) {}
  1. Dentro del bloque sincronizado, copia el valor actual de INSTANCE en una variable local instance. Esto se debe a que se aprovecha el smart cast, que solo está disponible para las variables locales.
var instance = INSTANCE
  1. Dentro del bloque synchronized, return instance al final del bloque synchronized. Ignora el error de discrepancia de tipos de devolución; nunca devolverás un valor nulo cuando termines.
return instance
  1. Sobre la instrucción return, agrega una instrucción if para verificar si instance es nulo, es decir, si aún no hay una base de datos.
if (instance == null) {}
  1. Si instance es null, usa el compilador de bases de datos para obtener una base de datos. En el cuerpo de la instrucción if, invoca Room.databaseBuilder y proporciona el contexto que pasaste, la clase de la base de datos y un nombre para la base de datos, sleep_history_database. Para quitar el error, deberás agregar una estrategia de migración y build() en los pasos siguientes.
instance = Room.databaseBuilder(
                           context.applicationContext,
                           SleepDatabase::class.java,
                           "sleep_history_database")
  1. Agrega la estrategia de migración necesaria al compilador. Usa .fallbackToDestructiveMigration().

    . Normalmente, tendrías que proporcionar un objeto de migración con una estrategia para cuando cambie el esquema. Un objeto de migración es un objeto que define cómo tomas todas las filas con el esquema anterior y las conviertes en filas en el esquema nuevo para que no se pierdan datos. La migración no se incluye en este codelab. Una solución simple es destruir y volver a compilar la base de datos, lo que significa que los datos se pierden.
.fallbackToDestructiveMigration()
  1. Por último, llama a .build().
.build()
  1. Asigna INSTANCE = instance como el paso final dentro de la instrucción if. 
INSTANCE = instance
  1. El código final debería verse así: 
@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. Compila y ejecuta tu código.

Ahora tienes todos los componentes básicos para trabajar con tu base de datos de Room. Este código se compila y se ejecuta, pero no puedes distinguir si funciona realmente. Por lo tanto, este es un buen momento para agregar algunas pruebas básicas.

Paso 2: Prueba SleepDatabase

En este paso, ejecutarás las pruebas proporcionadas para verificar que tu base de datos funcione. Esto ayuda a garantizar que la base de datos funcione antes de que la desarrolles. Las pruebas proporcionadas son básicas. En el caso de una app de producción, se ejercitarían todas las funciones y consultas en todos los DAO.

La app de partida contiene una carpeta androidTest. Esta carpeta androidTest contiene pruebas de unidades que involucran la instrumentación de Android, que es una forma elegante de decir que las pruebas necesitan el framework de Android, por lo que debes ejecutarlas en un dispositivo físico o virtual. Por supuesto, también puedes crear y ejecutar pruebas de unidades puras que no involucren el framework de Android.

  1. En Android Studio, en la carpeta androidTest, abre el archivo SleepDatabaseTest.
  2. Para quitar las marcas de comentario del código, selecciona todo el código comentado y presiona la combinación de teclas Cmd+/ o Control+/.
  3. Echa un vistazo al archivo.

A continuación, se incluye un resumen rápido del código de prueba, ya que es otro fragmento de código que puedes reutilizar:

  • SleepDabaseTest es una clase de prueba.
  • La anotación @RunWith identifica el ejecutor de pruebas, que es el programa que configura y ejecuta las pruebas.
  • Durante la configuración, se ejecuta la función anotada con @Before y se crea un SleepDatabase en la memoria con el SleepDatabaseDao. "En memoria" significa que esta base de datos no se guarda en el sistema de archivos y se borrará después de que se ejecuten las pruebas.
  • Además, cuando se compila la base de datos en memoria, el código llama a otro método específico de la prueba, allowMainThreadQueries. De forma predeterminada, recibirás un error si intentas ejecutar consultas en el subproceso principal. Este método te permite ejecutar pruebas en el subproceso principal, lo que solo debes hacer durante las pruebas.
  • En un método de prueba anotado con @Test, creas, insertas y recuperas un SleepNight, y afirmas que son iguales. Si algo sale mal, arroja una excepción. En una prueba real, tendrías varios métodos @Test .
  • Cuando finaliza la prueba, se ejecuta la función anotada con @After para cerrar la base de datos.
  1. Haz clic con el botón derecho en el archivo de prueba en el panel Project y selecciona Run 'SleepDatabaseTest'.
  2. Después de que se ejecuten las pruebas, verifica en el panel SleepDatabaseTest que se hayan aprobado todas.

Como se aprobaron todas las pruebas, ahora sabes varias cosas:

  • La base de datos se crea correctamente.
  • Puedes insertar un SleepNight en la base de datos.
  • Puedes recuperar el SleepNight.
  • El SleepNight tiene el valor correcto para la calidad.

Proyecto de Android Studio: TrackMySleepQualityRoomAndTesting

Cuando pruebes una base de datos, deberás ejercitar todos los métodos definidos en el DAO. Para completar las pruebas, agrega y ejecuta pruebas para ejercitar los otros métodos de DAO.

  • Define tus tablas como clases de datos anotadas con @Entity. Define las propiedades anotadas con @ColumnInfo como columnas en las tablas.
  • Define un objeto de acceso a datos (DAO) como una interfaz anotada con @Dao. El DAO asigna funciones de Kotlin a consultas de bases de datos.
  • Usa anotaciones para definir las funciones @Insert, @Delete y @Update.
  • Usa la anotación @Query con una cadena de consulta de SQLite como parámetro para cualquier otra consulta.
  • Crea una clase abstracta que tenga una función getInstance() que muestre una base de datos.
  • Usa pruebas instrumentadas para verificar que tu base de datos y tu DAO funcionen según lo esperado. Puedes usar las pruebas proporcionadas como plantilla.

Curso de Udacity:

Documentación para desarrolladores de Android:

Otros artículos y documentación:

En esta sección, se enumeran las posibles actividades para el hogar para los alumnos que trabajan en este codelab como parte de un curso dirigido por un instructor. Depende del instructor hacer lo siguiente:

  • Si es necesario, asigna una tarea.
  • Comunicarles a los alumnos cómo enviar las actividades para el hogar.
  • Califica las actividades para el hogar.

Los instructores pueden usar estas sugerencias en la medida que quieran y deben asignar cualquier otra actividad para el hogar que consideren apropiada.

Si estás trabajando en este codelab por tu cuenta, usa estas actividades para el hogar para probar tus conocimientos.

Responde estas preguntas:

Pregunta 1

¿Cómo se indica que una clase representa una entidad que se debe almacenar en una base de datos Room?

  • Se debe hacer que la clase extienda DatabaseEntity.
  • Anota la clase con @Entity.
  • Anota la clase con @Database.
  • Se debe hacer que la clase extienda RoomEntity y anotar la clase con @Room.

Pregunta 2

El DAO (objeto de acceso a datos) es una interfaz que Room usa para asignar funciones de Kotlin a consultas de bases de datos.

¿Cómo indicas que una interfaz representa un DAO para una base de datos Room?

  • Se debe hacer que la interfaz extienda RoomDAO.
  • Se debe hacer que la interfaz extienda EntityDao y luego implemente el método DaoConnection().
  • Anota la interfaz con @Dao.
  • Anota la interfaz con @RoomConnection.

Pregunta 3

¿Cuáles de las siguientes afirmaciones sobre la base de datos Room son verdaderas? Selecciona todas las opciones que correspondan.

  • Puedes definir tablas para una base de datos Room como clases de datos anotadas.
  • Si devuelves LiveData desde una búsqueda, Room mantendrá LiveData actualizado por ti si cambia LiveData.
  • Cada base de datos Room debe tener un DAO, y solo uno.
  • Para identificar una clase como una base de datos Room, conviértela en una subclase de RoomDatabase y anótala con @Database.

Pregunta 4

¿Cuáles de las siguientes anotaciones puedes usar en tu interfaz de @Dao? Selecciona todas las opciones que correspondan.

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

Pregunta 5

¿Cómo puedes verificar que tu base de datos funciona? Selecciona todas las opciones que correspondan.

  • Escribe pruebas instrumentadas.
  • Sigue escribiendo y ejecutando la app hasta que muestre los datos.
  • Reemplaza las llamadas a los métodos en la interfaz DAO por llamadas a métodos equivalentes en la clase Entity.
  • Ejecuta la función verifyDatabase() que proporciona la biblioteca Room.

Comienza la siguiente lección: 6.2 Corrutinas y Room

Para obtener vínculos a otros codelabs de este curso, consulta la página de destino de los codelabs de Conceptos básicos de Kotlin para Android.