Esta página foi traduzida pela API Cloud Translation.

Conceitos básicos do Kotlin para Android 06.1: criar um banco de dados do Room

Este codelab faz parte do curso Conceitos básicos do Kotlin para Android. Você vai aproveitar mais este curso se fizer os codelabs em sequência. Todos os codelabs do curso estão listados na página inicial dos codelabs de princípios básicos do Kotlin para Android.

Introdução

A maioria dos apps tem dados que precisam ser mantidos, mesmo depois que o usuário os fecha. Por exemplo, o app pode armazenar uma playlist, um inventário de itens de jogos, registros de despesas e renda, um catálogo de constelações ou dados de sono ao longo do tempo. Normalmente, você usaria um banco de dados para armazenar dados persistentes.

O Room é uma biblioteca de banco de dados que faz parte do Android Jetpack. O Room cuida de muitas das tarefas da configuração de um banco de dados, além de possibilitar que o app interaja com o banco de dados usando chamadas de função comuns. Por baixo dos panos, o Room é uma camada de abstração sobre um banco de dados SQLite. A terminologia do Room e a sintaxe de consulta para consultas mais complexas seguem o modelo do SQLite.

A imagem abaixo mostra como o banco de dados Room se encaixa na arquitetura geral recomendada neste curso.

O que você já precisa saber

Você precisa:

Criar uma interface do usuário (IU) básica para um app Android
Usando atividades, fragmentos e visualizações.
Navegar entre fragmentos e usar o Safe Args (um plug-in do Gradle) para transmitir dados entre eles.
Modelos de visualização, fábricas de modelos de visualização, LiveData e os observadores dele. Esses tópicos sobre componentes de arquitetura são abordados em um codelab anterior deste curso.
Noções básicas sobre os bancos de dados SQL e a linguagem SQLite. Consulte o Guia do SQLite para uma visão geral rápida ou uma atualização.

O que você vai aprender

Como criar e interagir com um banco de dados Room para manter os dados.
Como criar uma classe de dados que define uma tabela no banco de dados.
Como usar um objeto de acesso a dados (DAO, na sigla em inglês) para mapear funções Kotlin para consultas SQL.
Como testar se o banco de dados está funcionando.

Atividades deste laboratório

Crie um banco de dados Room com uma interface para dados de sono noturno.
Teste o banco de dados usando os testes fornecidos.

Neste codelab, você vai criar a parte do banco de dados de um app que monitora a qualidade do sono. O app usa um banco de dados para armazenar dados de sono ao longo do tempo.

O app tem duas telas, representadas por fragmentos, como mostrado na figura abaixo.

A primeira tela, mostrada à esquerda, tem botões para iniciar e parar o rastreamento. A tela mostra todos os dados de sono do usuário. O botão Limpar exclui permanentemente todos os dados que o app coletou do usuário.

A segunda tela, mostrada à direita, é para selecionar uma classificação de qualidade do sono. No app, a classificação é representada numericamente. Para fins de desenvolvimento, o app mostra os ícones de rosto e os equivalentes numéricos deles.

O fluxo do usuário é o seguinte:

O usuário abre o app e a tela de monitoramento do sono aparece.
O usuário toca no botão Iniciar. Isso registra e mostra o horário de início. O botão Iniciar está desativado, e o botão Parar está ativado.
O usuário toca no botão Parar. Isso registra o horário de término e abre a tela de qualidade do sono.
O usuário seleciona um ícone de qualidade do sono. A tela fecha, e a tela de monitoramento mostra a hora de fim do sono e a qualidade dele. O botão Parar está desativado, e o botão Iniciar está ativado. O app está pronto para outra noite.
O botão Limpar fica ativado sempre que há dados no banco de dados. Quando o usuário toca no botão Limpar, todos os dados são apagados sem recurso. Não há uma mensagem "Tem certeza?".

Esse app usa uma arquitetura simplificada, conforme mostrado abaixo no contexto da arquitetura completa. O app usa apenas os seguintes componentes:

Controlador de interface
Mostrar modelo e LiveData
Um banco de dados do Room

Etapa 1: fazer o download e executar o app inicial

Faça o download do app TrackMySleepQuality-Starter no GitHub.
Crie e execute o app. Ele vai mostrar a interface do fragmento SleepTrackerFragment, mas sem dados. Os botões não respondem aos toques.

Etapa 2: inspecionar o app inicial

Confira os arquivos do Gradle:

O arquivo Gradle do projeto
: no arquivo build.gradle do projeto, observe as variáveis que especificam as versões da biblioteca. As versões usadas no app inicial funcionam bem juntas e com esse app. Quando você terminar este codelab, o Android Studio poderá pedir para atualizar algumas das versões. Você decide se quer atualizar ou manter as versões que estão no app. Se você encontrar erros de compilação "estranhos", tente usar a combinação de versões de biblioteca que o app de solução final usa.
O arquivo Gradle do módulo. Observe as dependências fornecidas para todas as bibliotecas do Android Jetpack, incluindo Room, e as dependências para corrotinas.

Confira os pacotes e a interface. O app é estruturado por funcionalidade. O pacote contém arquivos de marcador de posição em que você vai adicionar código ao longo desta série de codelabs.

O pacote database, para todo o código relacionado ao banco de dados Room.
Os pacotes sleepquality e sleeptracker contêm o fragmento, o modelo de visualização e a fábrica do modelo de visualização para cada tela.

Confira o arquivo Util.kt, que contém funções para ajudar a mostrar dados de qualidade do sono. Alguns códigos estão comentados porque fazem referência a um modelo de visualização que você vai criar mais tarde.
Confira a pasta androidTest (SleepDatabaseTest.kt). Use esse teste para verificar se o banco de dados funciona conforme o esperado.

No Android, os dados são representados em classes de dados, e o acesso e a modificação deles são feitos usando chamadas de função. No entanto, no mundo dos bancos de dados, é necessário ter entidades e consultas.

Uma entidade representa um objeto ou conceito e as propriedades a serem armazenadas no banco de dados. Uma classe de entidade define uma tabela, e cada instância dessa classe representa uma linha na tabela. Cada propriedade define uma coluna. No app, a entidade vai armazenar informações sobre uma noite de sono.
Uma consulta é uma solicitação de dados ou informações de uma tabela de banco de dados ou uma combinação de tabelas, ou uma solicitação para realizar uma ação nos dados. As consultas comuns são para receber, inserir e atualizar entidades. Por exemplo, você pode consultar todas as noites de sono registradas, classificadas por horário de início.

O Room faz todo o trabalho pesado para você, desde classes de dados Kotlin até entidades que podem ser armazenadas em tabelas SQLite, e desde declarações de funções até consultas SQL.

É necessário definir cada entidade como uma classe de dados anotada e as interações como uma interface anotada, um objeto de acesso a dados (DAO). O Room usa essas classes anotadas para criar tabelas no banco de dados e consultas que atuam nele.

Etapa 1: criar a entidade SleepNight

Nesta tarefa, você vai definir uma noite de sono como uma classe de dados anotada.

Para uma noite de sono, você precisa registrar o horário de início, o horário de término e uma classificação de qualidade.

Além disso, você precisa de um ID para identificar a noite de forma exclusiva.

No pacote database, encontre e abra o arquivo SleepNight.kt.
Crie a classe de dados SleepNight com parâmetros para um ID, um horário de início (em milissegundos), um horário de término (em milissegundos) e uma classificação numérica da qualidade do sono.

É necessário inicializar o sleepQuality. Portanto, defina-o como -1, indicando que nenhum dado de qualidade foi coletado.
Você também precisa inicializar o horário de término. Defina como o horário de início para indicar que nenhum horário de término foi registrado ainda.

data class SleepNight(
       var nightId: Long = 0L,
       val startTimeMilli: Long = System.currentTimeMillis(),
       var endTimeMilli: Long = startTimeMilli,
       var sleepQuality: Int = -1
)

Antes da declaração de classe, adicione a anotação @Entity à classe de dados. Nomeie a tabela como daily_sleep_quality_table. O argumento para o tableName é opcional, mas recomendado. Consulte outros argumentos na documentação.

Se solicitado, importe Entity e todas as outras anotações da biblioteca androidx.

@Entity(tableName = "daily_sleep_quality_table")
data class SleepNight(...)

Para identificar o nightId como a chave primária, faça uma anotação na propriedade nightId com @PrimaryKey. Defina o parâmetro autoGenerate como true, para que o Room gere um ID para cada entidade. Isso garante que o ID de cada noite seja exclusivo.

@PrimaryKey(autoGenerate = true)
var nightId: Long = 0L,...

Faça uma anotação com @ColumnInfo nas propriedades restantes. Personalize os nomes de propriedade usando parâmetros, conforme mostrado abaixo.

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
)

Crie e execute o código para garantir que não haja erros.

Nesta tarefa, você vai definir um objeto de acesso a dados (DAO). No Android, o DAO oferece métodos convenientes para inserir, excluir e atualizar o banco de dados.

Ao usar um banco de dados Room, você o consulta definindo e chamando funções do Kotlin no seu código. Essas funções Kotlin são mapeadas para consultas SQL. Você define esses mapeamentos em um DAO usando anotações, e o Room cria o código necessário.

Pense em um DAO como a definição de uma interface personalizada para acessar seu banco de dados.

Para operações comuns do banco de dados, a biblioteca Room fornece anotações de conveniência, como @Insert, @Delete e @Update. A anotação @Query é usado para todo o restante. É possível programar qualquer consulta com suporte do SQLite.

Outro benefício é que, à medida que você cria suas consultas no Android Studio, o compilador verifica se há erros de sintaxe nas consultas SQL.

Para o banco de dados do rastreador de sono, você precisa fazer o seguinte:

Inserir novas diárias.
Atualize uma noite para mudar o horário de término e a classificação de qualidade.
Receber uma noite específica com base na chave dela.
Buscar todas as noites para poder mostrá-las.
Receba a noite mais recente.
Excluir todas as entradas do banco de dados.

Etapa 1: criar o DAO SleepDatabase

No pacote database, abra SleepDatabaseDao.kt.
Observe que interface SleepDatabaseDao tem a anotação @Dao. Todos os DAOs precisam ser anotados com a palavra-chave @Dao.

@Dao
interface SleepDatabaseDao {}

Dentro do corpo da interface, adicione uma anotação @Insert. Abaixo de @Insert, adicione uma função insert() que aceita uma instância do SleepNight da classe Entity como argumento.

Pronto. O Room vai gerar todo o código necessário para inserir o SleepNight no banco de dados. Quando você chama insert() no código Kotlin, o Room executa uma consulta SQL para inserir a entidade no banco de dados. Observação: você pode dar o nome que quiser à função.

@Insert
fun insert(night: SleepNight)

Adicione uma anotação @Update com uma função update() a um SleepNight. A entidade atualizada é a que tem a mesma chave da entidade transmitida. É possível atualizar algumas ou todas as outras propriedades da entidade.

@Update
fun update(night: SleepNight)

Não existe uma anotação de conveniência para as funções restantes. Portanto, é necessário usar a anotação @Query e oferecer consultas SQLite.

Adicione uma anotação @Query com uma função get() que usa um argumento Long key e retorna um SleepNight anulável. Um erro vai aparecer para um parâmetro ausente.

@Query
fun get(key: Long): SleepNight?

A consulta é fornecida como um parâmetro de string para a anotação. Adicione um parâmetro a @Query. Transforme em um String que seja uma consulta do SQLite.

Selecione todas as colunas do daily_sleep_quality_table.
WHERE (onde) o nightId corresponde ao argumento :key.

Observe o :key. Os dois pontos são usados na consulta para referenciar argumentos na função.

("SELECT * from daily_sleep_quality_table WHERE nightId = :key")

Adicione outro @Query com uma função clear() e uma consulta SQLite para DELETE tudo do daily_sleep_quality_table. Essa consulta não exclui a tabela.

A anotação @Delete exclui um item. Você pode usar @Delete e fornecer uma lista de noites para excluir. A desvantagem é que você precisa buscar ou saber o que está na tabela. A anotação @Delete é ótima para excluir entradas específicas, mas não é eficiente para limpar todas as entradas de uma tabela.

@Query("DELETE FROM daily_sleep_quality_table")
fun clear()

Adicione uma @Query com uma função getTonight(). Torne o SleepNight retornado por getTonight() anulável para que a função possa processar o caso em que a tabela está vazia. (A tabela fica vazia no início e depois que os dados são apagados.)

Para extrair "hoje à noite" do banco de dados, escreva uma consulta SQLite que retorne o primeiro elemento de uma lista de resultados ordenados por nightId em ordem decrescente. Use LIMIT 1 para retornar apenas um elemento.

@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC LIMIT 1")
fun getTonight(): SleepNight?

Adicione uma @Query com uma função getAllNights().

Faça com que a consulta SQLite retorne todas as colunas da tabela daily_sleep_quality_table, em ordem decrescente.
Faça com que getAllNights() retorne uma lista de entidades SleepNight como um LiveData. O Room mantém esse LiveData atualizado para você, o que significa que você só precisa receber os dados explicitamente uma vez.
Pode ser necessário importar o LiveData de androidx.lifecycle.LiveData.

@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC")
fun getAllNights(): LiveData<List<SleepNight>>

Não será possível visualizar nenhuma mudança, mas execute o app mesmo assim para garantir que não haja erros.

Nesta tarefa, você vai criar um banco de dados Room que usa o Entity e o DAO criados na tarefa anterior.

É necessário criar uma classe abstrata de contêiner de banco de dados, com a anotação @Database. Essa classe tem um método que cria uma instância do banco de dados, caso ele não exista, ou retorna uma referência a um banco de dados existente.

A obtenção de um banco de dados Room é um pouco complexa. Por isso, confira o processo geral antes de começar a programar:

Crie uma classe public abstract que extends RoomDatabase. Essa classe funciona como um contêiner de banco de dados. A classe é abstrata, porque o Room cria a implementação para você.
Adicione a anotação @Database à classe. Nos argumentos, declare as entidades do banco de dados e defina o número da versão.
Em um objeto companion, defina um método ou uma propriedade abstrata que retorne um SleepDatabaseDao. O Room vai gerar o corpo para você.
Só é necessária uma instância do banco de dados Room para todo o app. Portanto, transforme o RoomDatabase em um singleton.
Use o builder de banco de dados do Room para criar o banco de dados somente se ele não existir. Caso contrário, retorne o banco de dados existente.

Etapa 1: criar o banco de dados

No pacote database, abra SleepDatabase.kt.
No arquivo, crie uma classe abstract chamada SleepDatabase que estenda RoomDatabase.

Anote a classe com @Database.

@Database()
abstract class SleepDatabase : RoomDatabase() {}

Você vai encontrar um erro para entidades e parâmetros de versão ausentes. A anotação @Database requer vários argumentos para que o Room possa criar o banco de dados.

Forneça o SleepNight como o único item com a lista de entities.
Defina version como 1. Sempre que você mudar o esquema, será necessário aumentar o número da versão.
Defina o exportSchema como false, para não manter os backups do histórico de versões do esquema.

entities = [SleepNight::class], version = 1, exportSchema = false

O banco de dados precisa ser informado sobre o DAO. No corpo da classe, declare um valor abstrato que retorne o SleepDatabaseDao. É possível ter vários DAOs.

abstract val sleepDatabaseDao: SleepDatabaseDao

Abaixo disso, defina um objeto companion. O objeto complementar permite que os clientes acessem os métodos para criar ou consultar o banco de dados sem instanciar a classe. Como o único propósito dessa classe é fornecer um banco de dados, não há motivo para instanciá-la.

 companion object {}

Dentro do objeto companion, declare uma variável particular anulável INSTANCE para o banco de dados e a inicialize como null. A variável INSTANCE manterá uma referência ao banco de dados quando uma tiver sido criada. Isso ajuda a evitar a abertura repetida de conexões com o banco de dados, o que é caro.

Inclua a anotação @Volatile na INSTANCE. O valor de uma variável volátil nunca será armazenado em cache. Todas as gravações e leituras serão feitas de uma memória principal. Isso ajuda a garantir que o valor de INSTANCE esteja sempre atualizado e seja o mesmo para todas as linhas de execução. Isso significa que as mudanças feitas por uma linha de execução na INSTANCE ficam imediatamente visíveis para todas as outras. Assim, não há uma situação em que, por exemplo, duas linhas de execução atualizam a mesma entidade em um cache, o que criaria um problema.

@Volatile
private var INSTANCE: SleepDatabase? = null

Abaixo de INSTANCE, ainda dentro do objeto companion, defina um método getInstance() com um parâmetro Context, necessário para o builder do banco de dados. Retorne um tipo SleepDatabase. Você verá um erro, porque getInstance() ainda não retorna nada.

fun getInstance(context: Context): SleepDatabase {}

Em getInstance(), adicione um bloco synchronized{}. Transmita this para acessar o contexto.

Várias linhas de execução podem solicitar uma instância de banco de dados ao mesmo tempo, o que resulta em dois bancos de dados em vez de um. É improvável que esse problema aconteça neste app de exemplo, mas é possível em um app mais complexo. Envolver o código para receber o banco de dados em synchronized significa que somente uma linha de execução poderá entrar nesse bloco de código por vez, garantindo que o banco de dados será inicializado apenas uma vez.

synchronized(this) {}

Dentro do bloco sincronizado, copie o valor atual de INSTANCE para uma variável local instance. Isso é para aproveitar o smart cast, que está disponível apenas para variáveis locais.

var instance = INSTANCE

Dentro do bloco synchronized, return instance no final do bloco synchronized. Ignore o erro de incompatibilidade de tipo de retorno. Você nunca vai retornar nulo depois de terminar.

return instance

Acima da instrução return, adicione uma instrução if para verificar se instance é nulo, ou seja, se ainda não há um banco de dados.

if (instance == null) {}

Se instance for null, use o builder do banco de dados para acessar um banco de dados. No corpo da instrução if, invoque Room.databaseBuilder e forneça o contexto transmitido, a classe do banco de dados e um nome para o banco de dados, sleep_history_database. Para remover o erro, adicione uma estratégia de migração e build() nas etapas a seguir.

instance = Room.databaseBuilder(
                           context.applicationContext,
                           SleepDatabase::class.java,
                           "sleep_history_database")

Adicione a estratégia de migração necessária ao builder. Use .fallbackToDestructiveMigration().

Normalmente, é necessário fornecer um objeto de migração com uma estratégia de migração para os momentos em que o esquema mudar. Um objeto de migração é aquele que define como converter todas as linhas no esquema antigo em linhas no novo esquema, para que nenhum dado seja perdido. A migração (link em inglês) está além do escopo deste codelab. Uma solução simples é destruir e recriar o banco de dados, o que significa que os dados serão perdidos.

.fallbackToDestructiveMigration()

Por fim, chame .build().

.build()

Atribua INSTANCE = instance como a etapa final na instrução if.

INSTANCE = instance

O código concluído ficará assim:

@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
           }
       }
   }
}

Crie e execute o código.

Agora você tem todos os elementos básicos para trabalhar com o banco de dados Room. É possível compilar e executar esse código, mas ainda não dá para saber se ele realmente funciona. Portanto, este é um bom momento para adicionar alguns testes básicos.

Etapa 2: testar o SleepDatabase

Nesta etapa, você executa os testes fornecidos para verificar se o banco de dados funciona. Isso ajuda a garantir que o banco de dados funcione antes de você criar algo nele. Os testes fornecidos são básicos. Para um app de produção, você exercitaria todas as funções e consultas em todos os DAOs.

O app inicial contém uma pasta androidTest. Essa pasta androidTest contém testes de unidade que envolvem instrumentação do Android, que é uma maneira sofisticada de dizer que os testes precisam do framework Android. Portanto, é necessário executar os testes em um dispositivo físico ou virtual. É claro que você também pode criar e executar testes de unidade puros que não envolvem o framework Android.

No Android Studio, na pasta androidTest, abra o arquivo SleepDatabaseTest.
Para remover o comentário do código, selecione todo o código comentado e pressione o atalho de teclado Cmd+/ ou Control+/.
Dê uma olhada no arquivo.

Confira uma visão geral rápida do código de teste, porque ele é outra parte do código que você pode reutilizar:

SleepDabaseTest é uma classe de teste.
A anotação @RunWith identifica o executor de testes, que é o programa que configura e executa os testes.
Durante a configuração, a função anotada com @Before é executada e cria um SleepDatabase na memória com o SleepDatabaseDao. "Na memória" significa que esse banco de dados não é salvo no sistema de arquivos e será excluído após a execução dos testes.
Além disso, ao criar o banco de dados na memória, o código chama outro método específico para testes, allowMainThreadQueries. Por padrão, você recebe um erro se tentar executar consultas na linha de execução principal. Esse método permite executar testes na linha de execução principal, o que só deve ser feito durante os testes.
Em um método de teste anotado com @Test, você cria, insere e recupera um SleepNight e afirma que eles são iguais. Se algo der errado, gere uma exceção. Em um teste real, você teria vários métodos @Test .
Quando o teste é concluído, a função anotada com @After é executada para fechar o banco de dados.

Clique com o botão direito do mouse no arquivo de teste no painel Projeto e selecione Executar "SleepDatabaseTest".
Depois que os testes forem executados, verifique no painel SleepDatabaseTest se todos foram aprovados.

Como todos os testes foram aprovados, agora você sabe várias coisas:

O banco de dados é criado corretamente.
Você pode inserir um SleepNight no banco de dados.
Você pode recuperar o SleepNight.
O SleepNight tem o valor correto para a qualidade.

Projeto do Android Studio: TrackMySleepQualityRoomAndTesting (link em inglês)

Ao testar um banco de dados, é necessário exercitar todos os métodos definidos no DAO. Para concluir o teste, adicione e execute testes para exercitar os outros métodos do DAO.

Defina suas tabelas como classes de dados com a anotação @Entity. Defina as propriedades com a anotação @ColumnInfo como colunas em tabelas.
Defina um objeto de acesso a dados (DAO, na sigla em inglês) como uma interface com a anotação @Dao. O DAO mapeia funções do Kotlin para realizar consultas no banco de dados.
Use anotações para definir as funções @Insert, @Delete e @Update.
Use a anotação @Query com uma string de consulta do SQLite como parâmetro para outras consultas.
Crie uma classe abstrata com uma função getInstance() que retorne um banco de dados.
Use testes instrumentados para verificar se o banco de dados e o DAO estão funcionando conforme o esperado. Você pode usar os testes fornecidos como um modelo.

Curso da Udacity:

Desenvolvimento de apps Android com Kotlin

Documentação para desenvolvedores Android:

RoomDatabase
Database (anotações)
É possível usar consultas brutas com Room
Roomdatabase.Builder
Treinamento de teste
Classe SQLiteDatabase
Dao
Biblioteca de persistência Room

Outros documentos e artigos:

Padrão Singleton (link em inglês)
De Google Developer Experts: Sobre o uso adequado de volatile e synchronized
Objetos complementares (link em inglês)
Noções básicas sobre migrações com Room (link em inglês)
Testar migrações da Room (link em inglês)
Histórico de bancos de dados
Site do SQLite (link em inglês)
Descrição completa do SQL de acordo com o SQLite (link em inglês)

Esta seção lista as possíveis atividades de dever de casa para os alunos que estão fazendo este codelab como parte de um curso ministrado por um professor. Cabe ao professor fazer o seguinte:

Atribuir o dever de casa, se necessário.
Informar aos alunos como enviar deveres de casa.
Atribuir nota aos deveres de casa.

Os professores podem usar essas sugestões o quanto quiserem, podendo passar os exercícios que acharem mais apropriados como dever de casa.

Se você estiver seguindo este codelab por conta própria, sinta-se à vontade para usar esses deveres de casa para testar seu conhecimento.

Responda estas perguntas

Pergunta 1

Como você indica que uma classe representa uma entidade a ser armazenada em um banco de dados Room?

Faça a classe estender DatabaseEntity.
Adicione a anotação @Entity à classe.
Adicione a anotação @Database à classe.
Faça a classe estender RoomEntity e anote-a com @Room.

Pergunta 2

O DAO (objeto de acesso a dados) é uma interface que o Room usa para mapear funções do Kotlin para consultas de banco de dados.

Como é possível indicar que uma interface representa um DAO para um banco de dados Room?

Faça a interface estender RoomDAO.
Faça a interface estender EntityDao. Em seguida, implemente o método DaoConnection().
Adicione a anotação @Dao à interface.
Adicione a anotação @RoomConnection à interface.

Pergunta 3

Quais das seguintes afirmações sobre o banco de dados Room são verdadeiras? Escolha todas as opções relevantes.

É possível definir tabelas para um banco de dados Room como classes de dados anotadas.
Se você retornar LiveData de uma consulta, Room vai manter o LiveData atualizado para você se ele mudar.LiveData
Cada banco de dados Room precisa ter um, e apenas um, DAO.
Para identificar uma classe como um banco de dados Room, crie uma subclasse de RoomDatabase e adicione a anotação @Database.

Pergunta 4

Qual das seguintes anotações pode ser usada na interface @Dao? Escolha todas as opções relevantes.

@Get
@Update
@Insert
@Query

Pergunta 5

Como você pode verificar se o banco de dados está funcionando? Selecione todas as opções aplicáveis.

Criar testes instrumentados.
Continue escrevendo e executando o app até que ele mostre os dados.
Substitua as chamadas para os métodos na interface DAO por chamadas de métodos equivalentes na classe Entity.
Execute a função verifyDatabase() fornecida pela biblioteca Room.

Comece a próxima lição: 6.2 Corrotinas e Room

Para acessar links de outros codelabs neste curso, consulte a página inicial dos codelabs de conceitos básicos do Kotlin para Android.