A Cursor leaves a lot to be desired as a way to look at a table. All it does is give you raw column values. Pulling data out of a Cursor looks like this:

String uuidString = cursor.getString(
    cursor.getColumnIndex(CrimeTable.Cols.UUID));
String title = cursor.getString(
    cursor.getColumnIndex(CrimeTable.Cols.TITLE));
long date = cursor.getLong(
    cursor.getColumnIndex(CrimeTable.Cols.DATE));
int isSolved = cursor.getInt(
    cursor.getColumnIndex(CrimeTable.Cols.SOLVED));

Every time you pull a Crime out of a cursor, you need to write this code one more time. (And that does not include the code to create a Crime instance with those values!)

Remember the DRY rule of thumb: Don’t repeat yourself. Instead of writing this code each time you need to read data from a Cursor, you can create your own Cursor subclass that takes care of this in one place. The easiest way to write a Cursor subclass is to use CursorWrapper. A CursorWrapper lets you wrap a Cursor you received from another place and add new methods on top of it.

Create a new class in the database package called CrimeCursorWrapper.

public class CrimeCursorWrapper extends CursorWrapper {
    public CrimeCursorWrapper(Cursor cursor) {
        super(cursor);
    }
}

That creates a thin wrapper around a Cursor. It has all the same methods as the Cursor it wraps, and calling those methods does the exact same thing. This would be pointless, except that it makes it possible to add new methods that operate on the underlying Cursor.

Add a getCrime() method that pulls out relevant column data. (Remember to use the two-step import trick for CrimeTable here, as you did earlier.)

public class CrimeCursorWrapper extends CursorWrapper {
    public CrimeCursorWrapper(Cursor cursor) {
        super(cursor);
    }

    public Crime getCrime() {
        String uuidString = getString(getColumnIndex(CrimeTable.Cols.UUID));
        String title = getString(getColumnIndex(CrimeTable.Cols.TITLE));
        long date = getLong(getColumnIndex(CrimeTable.Cols.DATE));
        int isSolved = getInt(getColumnIndex(CrimeTable.Cols.SOLVED));

        return null;
    }
}

You will need to return a Crime with an appropriate UUID from this method. Add another constructor to Crime to do this.

public Crime() {
    this(UUID.randomUUID());
    mId = UUID.randomUUID();
    mDate = new Date();
}

public Crime(UUID id) {
    mId = id;
    mDate = new Date();
}

And then finish up getCrime().

public Crime getCrime() {
    String uuidString = getString(getColumnIndex(CrimeTable.Cols.UUID));
    String title = getString(getColumnIndex(CrimeTable.Cols.TITLE));
    long date = getLong(getColumnIndex(CrimeTable.Cols.DATE));
    int isSolved = getInt(getColumnIndex(CrimeTable.Cols.SOLVED));

    Crime crime = new Crime(UUID.fromString(uuidString));
    crime.setTitle(title);
    crime.setDate(new Date(date));
    crime.setSolved(isSolved != 0);

    return crime;
    return null;
}

(Android Studio will ask you to choose between java.util.Date and java.sql.Date. Even though you are dealing with databases, java.util.Date is the right choice here.)

With CrimeCursorWrapper, vending out a List<Crime> from CrimeLab will be straightforward. You need to wrap the cursor you get back from your query in a CrimeCursorWrapper, then iterate over it calling getCrime() to pull out its Crimes.

For the first part, update queryCrimes(…) to use CrimeCursorWrapper.

private Cursor queryCrimes(String whereClause, String[] whereArgs) {
private CrimeCursorWrapper queryCrimes(String whereClause, String[] whereArgs) {
    Cursor cursor = mDatabase.query(
            CrimeTable.NAME,
            null, // columns - null selects all columns
            whereClause,
            whereArgs,
            null, // groupBy
            null, // having
            null  // orderBy
    );

    return cursor;
    return new CrimeCursorWrapper(cursor);
}

Then get getCrimes() into shape. Add code to query for all crimes, walk the cursor, and populate a Crime list.

public List<Crime> getCrimes() {
    return new ArrayList<>();
    List<Crime> crimes = new ArrayList<>();

    CrimeCursorWrapper cursor = queryCrimes(null, null);

    try {
        cursor.moveToFirst();
        while (!cursor.isAfterLast()) {
            crimes.add(cursor.getCrime());
            cursor.moveToNext();
        }
    } finally {
        cursor.close();
    }

    return crimes;
}

Database cursors are called cursors because they always have their finger on a particular place in a query. So to pull the data out of a cursor, you move it to the first element by calling moveToFirst(), and then read in row data. Each time you want to advance to a new row, you call moveToNext(), until finally isAfterLast() tells you that your pointer is off the end of the data set.

The last important thing to do is to call close() on your Cursor. This bit of housekeeping is important. If you do not do it, your Android device will spit out nasty error logs to berate you. Even worse, if you make a habit out of it, you will eventually run out of open file handles and crash your app. So: Close your cursors.

CrimeLab.getCrime(UUID) will look similar to getCrimes(), except it will only need to pull the first item, if it is there.

public Crime getCrime(UUID id) {
    return null;
    CrimeCursorWrapper cursor = queryCrimes(
            CrimeTable.Cols.UUID + " = ?",
            new String[] { id.toString() }
    );

    try {
        if (cursor.getCount() == 0) {
            return null;
        }

        cursor.moveToFirst();
        return cursor.getCrime();
    } finally {
        cursor.close();
    }
}

That completes a few moving pieces:

Now you should be able to press New Crime and see the new Crime displayed in CrimePagerActivity. Run CriminalIntent and verify that you can do this. If you cannot, double-check your implementations from this chapter so far.

private class CrimeAdapter extends RecyclerView.Adapter<CrimeHolder> {
    ...
    @Override
    public int getItemCount() {
        return mCrimes.size();
    }

    public void setCrimes(List<Crime> crimes) {
        mCrimes = crimes;
    }
}

private void updateUI() {
    CrimeLab crimeLab = CrimeLab.get(getActivity());
    List<Crime> crimes = crimeLab.getCrimes();

    if (mAdapter == null) {
        mAdapter = new CrimeAdapter(crimes);
        mCrimeRecyclerView.setAdapter(mAdapter);
    } else {
        mAdapter.setCrimes(crimes);
        mAdapter.notifyDataSetChanged();
    }

    updateSubtitle();
}