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 en secuencia. Todos los codelabs del curso se detallan en la página de destino de codelabs sobre los aspectos básicos de Kotlin para Android.
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, una app podría almacenar una lista de reproducción, un inventario de artículos de juegos, 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 base 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 ella mediante llamadas a funciones comunes. De forma interna, Room
es una capa de abstracción que se ubica sobre una base de datos SQLite. La terminología de Room
y la sintaxis de las consultas para consultas más complejas siguen el modelo SQLite.
En la siguiente imagen, se muestra 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 de una app para Android
- Uso de actividades, fragmentos y vistas.
- La navegación entre fragmentos y el uso de Safe Args (un complemento de Gradle) para pasar datos entre fragmentos
- Visualiza modelos, fábricas de modelo de vista y
LiveData
y sus observadores. Estos temas de componentes de arquitectura se abordan en un codelab anterior de este curso. - Conocimientos básicos sobre las bases de datos SQL y el lenguaje SQLite Consulta SQLite Primer para obtener una descripción general o un repaso rápido.
Qué aprenderás
- Cómo crear una base de datos
Room
e 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
Room
con una interfaz para datos de sueño nocturnos. - 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 realiza 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. La pantalla muestra todos los datos de sueño del usuario. El botón Borrar borra de forma permanente todos los datos que la app recopiló para el usuario.
En la segunda pantalla, que se muestra a la derecha, se selecciona una calificación de calidad del sueño. En la app, la calificación se representa numéricamente. Para fines de desarrollo, la app muestra los íconos de rostro y sus equivalentes numéricos.
El flujo del usuario es el siguiente:
- El usuario abre la app y aparece la pantalla de seguimiento del sueño.
- El usuario presiona el botón Iniciar. Esto registra la hora de inicio y la muestra. El botón Iniciar está inhabilitado y está habilitado el botón Detener.
- El usuario presiona el botón Detener. Se grabará la hora de finalización y se abrirá la pantalla de calidad del sueño.
- El usuario selecciona un ícono de calidad del sueño. La pantalla se cerrará, y la pantalla de seguimiento mostrará la hora de finalización y la calidad del sueño. El botón Detener está inhabilitado y habilitado el botón Iniciar. La app está lista para otra noche.
- Se habilita el botón Borrar cuando la base de datos tiene datos. Cuando el usuario presiona el botón Borrar, se borran todos sus datos sin recursos, y no se muestra el mensaje "¿Estás seguro?".
Esta app usa una arquitectura simplificada, como se muestra a continuación en el contexto de la arquitectura completa. La app usa solo 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
- Descarga la app TrackMySleepQuality-Starter desde GitHub.
- Compila y ejecuta la app. La app muestra la IU para el fragmento
SleepTrackerFragment
, pero no los datos. Los botones no responden a toques.
Paso 2: Inspecciona la app de inicio
- Consulta los archivos de Gradle:
- El archivo Gradle del proyecto
En el archivobuild.gradle
del nivel del proyecto, observa las variables que especifican las versiones de biblioteca. Las versiones usadas en la app de inicio funcionan bien juntas, y también funcionan bien con esta app. Para el momento en que termines este codelab, es posible que Android Studio te solicite actualizar algunas de las versiones. Tú decides si deseas actualizar las versiones que se encuentran en la app o permanecer en ellas. Si experimentas errores de compilación, intenta usar la combinación de versiones de la biblioteca que usa la app de la 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.
- Observa los paquetes e IU. La app se estructura 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 deRoom
. - Los paquetes
sleepquality
ysleeptracker
contienen el fragmento, el modelo de vista y la fábrica de cada pantalla.
- Echa un vistazo al
Util.kt
archivo, que contiene funciones para ayudarte a mostrar datos sobre la calidad del sueño. Parte del código se comenta porque hace referencia a un modelo de vista que crearás más adelante. - Observa 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 los modifica mediante llamadas a funciones. Sin embargo, en el mundo de las bases de datos, necesitas entidades y consultas.
- Una entidad representa un objeto, o un 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á la 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 una solicitud para realizar una acción en los datos. Las consultas comunes se usan para obtener, insertar y actualizar entidades. Por ejemplo, puedes buscar todas las noches de sueño registradas, ordenadas por hora de inicio.
Room
hace todo el trabajo duro por ti, desde las clases de datos de Kotlin hasta las entidades que se pueden almacenar en tablas SQLite y desde declaraciones de funciones a consultas en SQL.
Debes definir cada entidad como una clase de datos anotados y las interacciones como una interfaz con anotaciones, un objeto de acceso de datos (DAO). Room
usa estas clases con anotaciones para crear tablas en la base de datos y búsquedas que actúan sobre ella.
Paso 1: Crea la entidad SleepSleep
En esta tarea, definirás una noche de sueño como una clase de datos anotados.
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 exclusiva a la noche.
- En el paquete
database
, busca y abre el archivoSleepNight.kt
. - 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 calidad del sueño.
- Tienes que inicializar
sleepQuality
, por lo que debes configurarlo en-1
, lo que indica que no se recopilaron datos de calidad. - y que debe inicializar la hora de finalización. Configúrala como la hora de inicio para indicar que todavía no se registró una hora de finalización.
data class SleepNight(
var nightId: Long = 0L,
val startTimeMilli: Long = System.currentTimeMillis(),
var endTimeMilli: Long = startTimeMilli,
var sleepQuality: Int = -1
)
- Antes de la declaración de la clase, anota la clase de datos con
@Entity
. Asígnale el nombredaily_sleep_quality_table
a la tabla. El argumento detableName
es opcional, pero se recomienda. Puedes buscar otros argumentos en la documentación.
Si se te solicita, importaEntity
y todas las demás anotaciones de la bibliotecaandroidx
.
@Entity(tableName = "daily_sleep_quality_table")
data class SleepNight(...)
- Para identificar
nightId
como la clave primaria, anota la propiedadnightId
con@PrimaryKey
. Establece el parámetroautoGenerate
entrue
para queRoom
genere el ID de cada entidad. Esto garantiza que el ID de cada noche sea único.
@PrimaryKey(autoGenerate = true)
var nightId: Long = 0L,...
- 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
)
- Compila y ejecuta tu código para asegurarte de que no tenga errores.
En esta tarea, definirá 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
, debes buscar en la base de datos definiendo y llamando a funciones de Kotlin en tu código. Estas funciones de Kotlin se asignan a consultas de SQL. Debes definir esas asignaciones en un DAO mediante anotaciones, y Room
crea el código necesario.
Considera un DAO como 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 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 seguimiento de sueño de las noches de sueño, debes hacer lo siguiente:
- Insertar noches nuevas
- Actualizar una noche existente para modificar la hora de finalización y la calificación de calidad
- Obtener una noche específica según la clave
- Recibe todas las noches para que puedas mostrarlas.
- Entérate de la noche más reciente.
- Borra todas las entradas de la base de datos.
Paso 1: Crea el DAO de SleepDatabase
- En el paquete
database
, abreSleepDatabaseDao.kt
. - Ten en cuenta que
interface
SleepDatabaseDao
tiene anotaciones con@Dao
. Todos los DAO deben estar anotados con la palabra clave@Dao
.
@Dao
interface SleepDatabaseDao {}
- Dentro del cuerpo de la interfaz, agrega una anotación
@Insert
. Debajo de@Insert
, agrega una funcióninsert()
que tome una instancia de la claseEntity
SleepNight
como su argumento.
Eso es todo.Room
generará todo el código necesario para insertarSleepNight
en la base de datos. Cuando llamas ainsert()
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 quieras).
@Insert
fun insert(night: SleepNight)
- Agrega una anotación
@Update
con una funciónupdate()
para unSleepNight
. La entidad que se actualiza es la que tiene la misma clave que la que se pasó. 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.
- Agrega una anotación
@Query
con una funciónget()
que tome un argumentoLong
key
y muestre unSleepNight
anulable. Verás un error por un parámetro faltante.
@Query
fun get(key: Long): SleepNight?
- La consulta se proporciona como un parámetro de string a la anotación. Agrega un parámetro a
@Query
. Haz que sea unaString
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")
- Agrega otro
@Query
con una funciónclear()
y una consulta de SQLite aDELETE
todo desdedaily_sleep_quality_table
. Esta consulta no borra la tabla.
La anotación@Delete
borra un elemento, por lo que puedes usar@Delete
y proporcionar una lista de noches para borrar. La desventaja es que necesitas recuperar o saber lo que hay en la tabla. La anotación@Delete
es ideal para borrar entradas específicas, pero no es eficiente a fin de borrar todas las entradas de una tabla.
@Query("DELETE FROM daily_sleep_quality_table")
fun clear()
- Agrega un
@Query
con una funcióngetTonight()
. Haz que laSleepNight
que muestragetTonight()
sea anulable, de modo 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 borrar los datos).
Para obtener esta noche desde la base de datos, escribe una consulta de SQLite que muestre el primer elemento de una lista de resultados ordenados pornightId
en orden descendente. UsaLIMIT 1
para mostrar solo un elemento.
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC LIMIT 1")
fun getTonight(): SleepNight?
- Agrega una
@Query
con una funcióngetAllNights()
:
- Haz que la consulta de SQLite muestre todas las columnas de
daily_sleep_quality_table
, en orden descendente. - Haz que
getAllNights()
muestre una lista de entidadesSleepNight
comoLiveData
.Room
mantiene esteLiveData
actualizado por ti, lo que significa que solo necesitas obtener los datos de forma explícita una vez. - Es posible que debas importar
LiveData
deandroidx.lifecycle.LiveData
.
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC")
fun getAllNights(): LiveData<List<SleepNight>>
- 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 de Room
que use el Entity
y el DAO que creaste en la tarea anterior.
Debes crear una clase de contenedor de bases de datos abstracta, anotada con @Database
. Esta clase tiene un método que crea una instancia de la base de datos si esta no existe o muestra una referencia a una base de datos existente.
Obtener una base de datos de Room
es un poco complejo, por lo que este es el proceso general antes de comenzar con el código:
- Crea una clase
public abstract
queextends RoomDatabase
. Esta clase actuará como un contenedor de base de datos. La clase es abstracta porqueRoom
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 abstracta que muestre unSleepDatabaseDao
.Room
generará el cuerpo para ti. - Solo necesitas una instancia de la base de datos de
Room
para toda la app, así que haz queRoomDatabase
sea un singleton. - Usa el compilador de bases de datos de
Room
para crear la base de datos solo si esta no existe. De lo contrario, muestra la base de datos existente.
Paso 1: Crea la base de datos
- En el paquete
database
, abreSleepDatabase.kt
. - En el archivo, crea una clase
abstract
llamadaSleepDatabase
que extiendaRoomDatabase
.
Anota la clase con@Database
.
@Database()
abstract class SleepDatabase : RoomDatabase() {}
- Verás un error para las entidades y los parámetros de versión faltantes. La anotación
@Database
requiere varios argumentos para queRoom
pueda compilar la base de datos.
- Proporciona
SleepNight
como el único elemento con la lista deentities
. - Establece
version
como1
. Cuando cambies el esquema, tendrás que aumentar el número de versión. - Establece
exportSchema
comofalse
para que no se conserven las copias de seguridad del historial de versiones de esquemas.
entities = [SleepNight::class], version = 1, exportSchema = false
- 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
- Debajo, 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 motivo para crear una instancia.
companion object {}
- Dentro del objeto
companion
, declara una variable anulable privadaINSTANCE
para la base de datos y, luego, inicializala ennull
. La variableINSTANCE
mantendrá una referencia a la base de datos, una vez que se haya creado una. Esto ayuda a evitar la apertura reiterada de conexiones a la base de datos, lo cual es 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. Eso 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 crearía un problema.
@Volatile
private var INSTANCE: SleepDatabase? = null
- Debajo de
INSTANCE
, aún dentro del objetocompanion
, define un métodogetInstance()
con un parámetroContext
que necesite el compilador de bases de datos. Muestra un tipoSleepDatabase
. Verás un error porquegetInstance()
todavía no muestra nada.
fun getInstance(context: Context): SleepDatabase {}
- Dentro de
getInstance()
, agrega un bloquesynchronized{}
. Pasathis
para que puedas acceder al contexto.
Varios subprocesos pueden solicitar una instancia de base de datos al mismo tiempo, lo que genera dos bases de datos en lugar de una. Es probable que este problema no ocurra en esta app de muestra, pero es posible que en una app más compleja una unión del código para obtener la base de datos ensynchronized
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) {}
- Dentro del bloque sincronizado, copia el valor actual de
INSTANCE
en una variable localinstance
. De esta manera, se aprovecha la transmisión inteligente, que solo está disponible para las variables locales.
var instance = INSTANCE
- Dentro del bloque
synchronized
,return instance
al final del bloquesynchronized
. Ignore el error de discrepancia en el tipo de datos que se muestra. Una vez que haya terminado, no se mostrará el valor nulo.
return instance
- Arriba de la declaración
return
, agrega una sentenciaif
para verificar siinstance
es nulo, es decir, aún no hay una base de datos.
if (instance == null) {}
- Si
instance
esnull
, usa el compilador de bases de datos para obtener una base de datos. En el cuerpo de la sentenciaif
, invoca aRoom.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, debes agregar una estrategia de migración ybuild()
en los siguientes pasos.
instance = Room.databaseBuilder(
context.applicationContext,
SleepDatabase::class.java,
"sleep_history_database")
- 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 se toman todas las filas con el esquema anterior y se convierten en filas en el esquema nuevo, de modo 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()
- Por último, llama a
.build()
.
.build()
- Asigna
INSTANCE = instance
como el último paso dentro de la sentenciaif
.
INSTANCE = instance
- 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
}
}
}
}
- 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. Este es un buen momento para agregar algunas pruebas básicas.
Paso 2: Prueba la base de datos de sueño
En este paso, ejecutarás pruebas proporcionadas para verificar que tu base de datos funcione. Esto ayuda a garantizar que la base de datos funcione antes de que la compiles. Las pruebas proporcionadas son básicas. Para una app de producción, debes aplicar todas las funciones y consultas en todos los DAO.
La app de inicio contiene una carpeta androidTest. Esta carpeta androidTest contiene pruebas de unidades que involucran instrumentación de Android. Es una forma sofisticada 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 incluyan el framework de Android.
- En Android Studio, en la carpeta androidTest, abre el archivo SleepDatabaseTest.
- Para quitar el comentario del código, selecciónalo y presiona la combinación de teclas
Cmd+/
oControl+/
. - Mira el archivo.
A continuación, se presenta un recorrido 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 unSleepDatabase
en la memoria con elSleepDatabaseDao
. "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 la memoria, el código llama a otro método específico de 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, que solo debes hacer durante las pruebas. - En un método de prueba anotado con
@Test
, creas, insertas y recuperas un elementoSleepNight
, y declaras que son iguales. Si algo sale mal, genera una excepción. En una prueba real, tendrías varios métodos@Test
. - Cuando se completan las pruebas, se ejecuta la función con la anotación
@After
para cerrar la base de datos.
- Haz clic con el botón derecho en el archivo de prueba en el panel Project y selecciona Run 'SleepDatabaseTest'.
- Después de que se ejecuten las pruebas, verifica en el panel SleepDatabaseTest que se hayan aprobado todas las pruebas.
Debido a que todas las pruebas fueron exitosas, ahora sabes varias cosas:
- La base de datos se crea de forma correcta.
- Puedes insertar una
SleepNight
en la base de datos. - Puedes recuperar el
SleepNight
. SleepNight
tiene el valor correcto para la calidad.
Proyecto de Android Studio: TrackMySleepQualityRoomAndTesting
Cuando pruebas una base de datos, debes ejercer todos los métodos definidos en el DAO. A fin de completar las pruebas, agrega y ejecuta pruebas para ejercitar los otros métodos 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 string 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 DAO funcionen según lo esperado. Puedes usar las pruebas proporcionadas como plantilla.
Curso de Udacity:
Documentación para desarrolladores de Android:
RoomDatabase
Database
(anotaciones)- Puedes usar búsquedas sin procesar con
Room
Roomdatabase.Builder
- Capacitación sobre pruebas
- Clase
SQLiteDatabase
Dao
- Biblioteca de persistencias
Room
Otros documentos y artículos:
En esta sección, se enumeran las posibles tareas para los alumnos que trabajan con este codelab como parte de un curso que dicta un instructor. Depende del instructor hacer lo siguiente:
- Si es necesario, asigna la tarea.
- Informa a los alumnos cómo enviar los deberes.
- Califica las tareas.
Los instructores pueden usar estas sugerencias lo poco o lo que quieran, y deben asignar cualquier otra tarea que consideren apropiada.
Si estás trabajando en este codelab por tu cuenta, usa estas tareas para poner a prueba tus conocimientos.
Responde estas preguntas
Pregunta 1
¿Cómo indicas que una clase representa una entidad para almacenar en una base de datos de Room
?
- Haz que la clase extienda
DatabaseEntity
. - Anota la clase con
@Entity
. - Anota la clase con
@Database
. - Haz que la clase extienda
RoomEntity
y anótala también 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 se indica que una interfaz representa un DAO para una base de datos Room
?
- Haz que la interfaz extienda
RoomDAO
. - Haz que la interfaz extienda
EntityDao
y, luego, implementa el métodoDaoConnection()
. - Anota la interfaz con
@Dao
. - Anota la interfaz con
@RoomConnection
.
Pregunta 3
¿Cuáles de las siguientes afirmaciones son verdaderas sobre la base de datos de Room
? Elige todas las opciones que correspondan.
- Puedes definir tablas para una base de datos
Room
como clases de datos anotados. - Si muestras
LiveData
desde una búsqueda,Room
mantendrá actualizadoLiveData
si cambiaLiveData
. - Cada base de datos de
Room
debe tener un único DAO. - Para identificar una clase como una base de datos
Room
, haz que sea una subclase deRoomDatabase
y anótala con@Database
.
Pregunta 4
¿Cuál de las siguientes anotaciones puedes usar en la interfaz @Dao
? Elige 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.
- Se deben escribir 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 bibliotecaRoom
.
Comience con la siguiente lección:
Para ver vínculos a otros codelabs de este curso, consulta la página de destino de codelabs sobre aspectos básicos de Kotlin para Android.