Pocket Notes 6 — search and final polish

The chapter where forty notes becomes a problem

Everything works. You can write, edit, delete and undo. Use the app for a fortnight and it will hold somewhere between thirty and a hundred notes, and at about that point something quietly stops working: finding one.

Scrolling is fine for twelve notes. At forty it is a chore. At a hundred it is faster to give up and write the thing down again, which is how notes apps end up with four copies of the same shopping list.

This chapter adds the box that fixes it, and then four small things that finish the app.

One more field in the state

1data class NotesUiState(
2    val notes: List<Note> = emptyList(),
3    val query: String = "",
4    val total: Int = 0,
5    val loading: Boolean = true
6)

notes is now the filtered list you can see. total is how many notes exist at all.

Those two numbers are what let the screen tell apart the two ways a list can be empty. A brand-new user with nothing saved needs "No notes yet — tap +". Somebody with two hundred notes who typed "beekeping" needs "Nothing found". Show the first message to the second person and the app looks like it just lost everything they own.

One extra Int in one data class, and that whole class of confusion disappears.

Where the filtering happens

And the filter itself, at the bottom of the same file, outside the class:

1/** Case-insensitive match on title or body. */
2private fun List<Note>.search(q: String): List<Note> {
3    if (q.isBlank()) return this
4    return filter {
5        it.title.contains(q, ignoreCase = true) ||
6            it.body.contains(q, ignoreCase = true)
7    }
8}

An extension function on List<Note>, so it reads as notes.search(q) at the call site. private means it belongs to this file and nothing else can call it.

Three details worth naming. if (q.isBlank()) return this short-circuits the common case — no typing means no work, and it returns the same list object rather than a copy. || searches the title or the body, because you will remember one or the other and rarely both. And ignoreCase = true is the difference between an app that finds your note and an app that technically works.

Why not do it in SQL?

You could. SELECT * FROM notes WHERE title LIKE :q is a real option, and for some apps it is the right one.

Pocket Notes filters in Kotlin because a phone's worth of notes is a small list — a few hundred short strings, already in memory, already delivered by Room's live query. Scanning that costs less than the round trip to SQLite would, and it keeps the DAO to five obvious functions with no escaping, no wildcards and no % concatenation.

The line to watch for is size. If this were a chat app with fifty thousand messages, the filtering would have to move into the database, and the tool would be a full-text search table rather than LIKE. That is a real and interesting piece of work — and it would happen entirely inside NoteDao and NotesRepository, with NoteListScreen untouched. Which is the argument for having a repository in the first place.

The box

Three states, one when

The content slot of NoteListScreen changes from a Box to a Column, so the field can sit above the list.

The list's top padding drops from 8dp to 4dp at the same time, because the search field's own 8dp bottom margin now supplies the gap.

And the second empty state is six lines, because chapter 3 split EmptyNotes into a thin wrapper around a private EmptyMessage:

1/** Shown when a search matches nothing. */
2@Composable
3fun NoSearchResults(
4    query: String,
5    modifier: Modifier = Modifier
6) {
7    EmptyMessage(
8        icon = Icons.Outlined.SearchOff,
9        title = "Nothing found",
10        body = "No note contains \"$query\". " +
11            "Try a shorter word.",
12        modifier = modifier
13    )
14}

Same 96dp honey circle, same layout, same spacing — a different glyph and different words. That split looked like over-engineering three chapters ago. This is the invoice being paid.

The last three touches

A live word count

One actions block on the editor's app bar:

1                actions = {
2                    Text(
3                        text = wordCount(body),
4                        style = type.labelMedium,
5                        color = colors.onSurfaceVariant,
6                        modifier = Modifier
7                            .padding(end = 16.dp)
8                    )
9                },

and a helper at the bottom of the file:

1/** "0 words", "1 word", "42 words". */
2private fun wordCount(text: String): String {
3    val words = text
4        .split(' ', '\n', '\t')
5        .count { it.isNotBlank() }
6    return if (words == 1) "1 word" else "$words words"
7}

split on three characters produces a lot of empty strings — two spaces in a row give you one — so count { it.isNotBlank() } does the real counting rather than .size. And the if on the last line exists because "1 words" is the kind of detail that makes an app feel unfinished.

There is no remember and no state here. body is already state; when it changes the app bar recomposes and calls wordCount again. Counting a few hundred characters on each keystroke is cheap, and putting it in state would mean keeping two things in step that are really one thing.

The keyboard stops covering the note

Two halves, and you need both. In the editor's content Column:

1        Column(
2            modifier = Modifier
3                .fillMaxSize()
4                .padding(inner)
5                // Lifts the text above the keyboard.
6                .imePadding()
7                .padding(horizontal = 8.dp)
8        ) {

and in the manifest:

1    <activity
2      android:name=".MainActivity"
3      android:exported="true"
4      android:label="@string/app_name"
5      android:windowSoftInputMode="adjustResize"
6      android:theme="@style/Theme.PocketNotes">

The app calls enableEdgeToEdge(), which means it draws underneath the system bars and takes responsibility for everything the system used to handle. imePadding adds bottom padding equal to the keyboard's height, so the body field shrinks instead of being covered. windowSoftInputMode="adjustResize" is Android's half of the same agreement: resize the window rather than sliding the whole thing upwards.

Leave out either one and the bottom of a long note sits behind the keys with no error to explain it.

What the finished app looks like

Now make it yours

Pocket Notes is finished, and it is a much better base to break than Dice Duel was. Three additions, in rising order of difficulty.

Sort options. The cheapest of the three and a good warm-up. Add a small menu to the list's app bar — IconButton plus DropdownMenu, both plain Material 3 — offering "Recently updated", "Title A–Z" and "Oldest first". Hold the choice as a third MutableStateFlow in the ViewModel and add it to the combine, exactly the way query was added here. The sorting itself is one sortedBy after the search. Notice how little of the app you have to touch: one flow, one line in combine, one menu. That is the shape a well-layered app gives you.

Pinned notes. Add val pinned: Boolean = false to Note, and immediately meet the thing chapter 1 warned about: changing an entity changes the table, so version = 1 becomes version = 2 and Room demands either a Migration or fallbackToDestructiveMigration(). Use the real migration — ALTER TABLE notes ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0 — so that nobody loses their notes to your new feature. Then ORDER BY pinned DESC, updatedAt DESC in the DAO, a pin icon on the card, and a long-press to toggle it.

Colour tags. The most design work and the most interesting. Store an Int on the note — 0 for none, 1–5 for the colours — and paint a strip down the leading edge of the card. The temptation is to store a hex value; resist it, because a stored colour cannot follow the theme into dark mode. Store the meaning and look the colour up from your palette at draw time. Then add a row of filter chips above the list and combine them with the search text, which means your combine block is now doing two kinds of narrowing at once — and you will be very glad you kept it in one place.