Room structures the database tables for your application based on the entities you define. Entities are model classes you create, annotated with the @Entity annotation. Room will create a database table for any class with that annotation.

Since you want to store crime objects in your database, update Crime to be a Room entity. Open Crime.kt and add two annotations:

@Entity
data class Crime(@PrimaryKey val id: UUID = UUID.randomUUID(),
                 var title: String = "",
                 var date: Date = Date(),
                 var isSolved: Boolean = false)

The first annotation, @Entity, is applied at the class level. This entity annotation indicates that the class defines the structure of a table, or set of tables, in the database. In this case, each row in the table will represent an individual Crime. Each property defined on the class will be a column in the table, with the name of the property as the name of the column. The table that stores your crimes will have four columns: id, title, date, and isSolved.

The other annotation you added is @PrimaryKey, which you added to the id property. This annotation specifies which column in your database is the primary key. The primary key in a database is a column that holds data that is unique for each entry, or row, so that it can be used to look up individual entries. The id property is unique for every Crime, so by adding @PrimaryKey to this property you will be able to query a single crime from the database using its id.

Now that your Crime class is annotated, you can move on to creating your database class.

Entity classes define the structure of database tables. A single entity class could be used across multiple databases, should your app have more than one database. That case is not common, but it is possible. For this reason, an entity class is not used by Room to create a table unless you explicitly associate it with a database, which you will do shortly.

First, create a new package called database for your database-specific code. In the project tool window, right-click the com.bignerdranch.android.criminalintent folder and choose New → Package. Name your new package database.

Now, create a new class called CrimeDatabase in the database package and define the class as shown below.

@Database(entities = [ Crime::class ], version=1)
abstract class CrimeDatabase : RoomDatabase() {
}

The @Database annotation tells Room that this class represents a database in your app. The annotation itself requires two parameters. The first parameter is a list of entity classes, which tells Room which entity classes to use when creating and managing tables for this database. In this case, you only pass the Crime class, since it is the only entity in the app.

The second parameter is the version of the database. When you first create a database, the version should be 1. As you develop your app in the future, you may add new entities and new properties to existing entities. When this happens, you will need to modify your entities list and increment your database version to tell Room something has changed. (You will do this in Chapter 15.)

The database class itself is empty at this point. CrimeDatabase extends from RoomDatabase and is marked as abstract, so you cannot make an instance of it directly. You will learn how to use Room to get a database instance you can use later in this chapter.

class CrimeTypeConverters {

    @TypeConverter
    fun fromDate(date: Date?): Long? {
        return date?.time
    }

    @TypeConverter
    fun toDate(millisSinceEpoch: Long?): Date? {
        return millisSinceEpoch?.let {
            Date(it)
        }
    }

    @TypeConverter
    fun toUUID(uuid: String?): UUID? {
        return UUID.fromString(uuid)
    }

    @TypeConverter
    fun fromUUID(uuid: UUID?): String? {
        return uuid?.toString()
    }
}

@Database(entities = [ Crime::class ], version=1)
@TypeConverters(CrimeTypeConverters::class)
abstract class CrimeDatabase : RoomDatabase() {
}