Design the components and overall architecture for a Search feature in an Android application.

package com.androidinterview.search.query;

// Debounce, as a decision rather than a timer, so the rule is testable without
// a clock. Flow.debounce sits on top of this in the app, and this is what it
// is actually deciding.
//
// Two filters matter as much as the delay. A query that trims to the same text
// as the last one fires nothing, which covers a user adding and deleting a
// space, and anything under the minimum length fires nothing, because a single
// letter matches most of the catalogue and costs a full search to find out.
//
// Clearing the field resets the last accepted query. Without that, searching
// shoes, clearing, and typing shoes again is refused forever, and the user is
// left with an empty screen and a field that will not search.
public final class QueryGate {

    private final long debounceMillis;
    private final int minLength;
    private String lastAccepted = "";

    public QueryGate(long debounceMillis, int minLength) {
        this.debounceMillis = debounceMillis;
        this.minLength = minLength;
    }

    public boolean accept(String raw, long lastKeystrokeAt, long nowMillis) {
        String query = raw.trim();
        if (query.isEmpty()) {
            lastAccepted = "";
            return false;
        }
        if (query.length() < minLength || query.equals(lastAccepted)) return false;
        if (nowMillis - lastKeystrokeAt < debounceMillis) return false;
        lastAccepted = query;
        return true;
    }

    // Suggestions are a different call with a different budget, so they get a
    // different gate. A suggestion that arrives after the user finished typing
    // has failed, which is why it fires sooner and asks for less.
    public static QueryGate forSuggestions() {
        return new QueryGate(120, 1);
    }

    public static QueryGate forFullSearch() {
        return new QueryGate(350, 2);
    }
}

package com.androidinterview.search.query;

// Latest wins, and this is the bug that only shows up on a bad connection.
//
// A user types shoe, then shoes. Two requests are in flight. The response for
// shoe comes back second because that connection happened to be slower, and
// the screen now shows results for a query the user has already moved past.
// Cancelling the in flight call is the first half of the fix. Stamping every
// request and rendering only the newest is the half that actually holds,
// because a cancellation can always lose the race.
//
// Issued and read on the main thread, which is why there is no lock here. In a
// Flow this file disappears entirely, because flatMapLatest cancels the
// previous collection for you.
public final class RequestSequence {

    private long issued;

    public long next() {
        return ++issued;
    }

    public boolean isCurrent(long generation) {
        return generation == issued;
    }
}

package com.androidinterview.search.results;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.List;

// What the screen shows before a single letter is typed, which is the half of
// a search feature that is usually left until last. A Room table behind this
// in a real app, bounded, newest first, with a repeat moving to the top rather
// than appearing twice.
public final class RecentSearches {

    private final Deque<String> queries = new ArrayDeque<>();
    private final int limit;

    public RecentSearches(int limit) {
        this.limit = limit;
    }

    public void record(String query) {
        queries.remove(query);
        queries.addFirst(query);
        if (queries.size() > limit) queries.removeLast();
    }

    public List<String> all() {
        return List.copyOf(queries);
    }
}

package com.androidinterview.search.results;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

// Local first, then the network on top. The local pass comes from a Room table
// of recent results and whatever slice of the catalogue is synced, and it
// paints in a frame instead of a round trip.
//
// The merge rule is the point. Server ranking wins for anything the server
// returned, because relevance is computed there with the data to do it with,
// and the local extras keep their place underneath rather than being
// interleaved by a score the client invented.
public final class ResultMerge {

    // local is what the row renders as a cached badge, so the user can tell an
    // instant local hit from a server ranked one.
    public record Result(String id, String title, boolean local) {
    }

    private ResultMerge() {
    }

    public static List<Result> merge(List<Result> local, List<Result> remote) {
        List<Result> merged = new ArrayList<>(remote);
        Set<String> seen = new HashSet<>();
        for (Result result : remote) seen.add(result.id());
        for (Result result : local) {
            if (seen.add(result.id())) merged.add(result);
        }
        return merged;
    }
}

package com.androidinterview.search.query

// Debounce, as a decision rather than a timer, so the rule is testable without
// a clock. Flow.debounce sits on top of this in the app, and this is what it
// is actually deciding.
//
// Two filters matter as much as the delay. A query that trims to the same text
// as the last one fires nothing, which covers a user adding and deleting a
// space, and anything under the minimum length fires nothing, because a single
// letter matches most of the catalogue and costs a full search to find out.
//
// Clearing the field resets the last accepted query. Without that, searching
// shoes, clearing, and typing shoes again is refused forever, and the user is
// left with an empty screen and a field that will not search.
class QueryGate(private val debounceMillis: Long, private val minLength: Int) {

    private var lastAccepted = ""

    fun accept(raw: String, lastKeystrokeAt: Long, nowMillis: Long): Boolean {
        val query = raw.trim()
        if (query.isEmpty()) {
            lastAccepted = ""
            return false
        }
        if (query.length < minLength || query == lastAccepted) return false
        if (nowMillis - lastKeystrokeAt < debounceMillis) return false
        lastAccepted = query
        return true
    }

    // Suggestions are a different call with a different budget, so they get a
    // different gate. A suggestion arriving after the user finished typing has
    // failed, which is why it fires sooner and asks for less.
    companion object {
        fun forSuggestions() = QueryGate(debounceMillis = 120, minLength = 1)
        fun forFullSearch() = QueryGate(debounceMillis = 350, minLength = 2)
    }
}

// Latest wins, and this is the bug that only shows up on a bad connection. A
// user types shoe, then shoes, and the slower response for shoe lands second
// and paints results for a query already moved past. Cancelling the in flight
// call is the first half of the fix. Stamping every request and rendering only
// the newest is the half that holds, because a cancellation can lose the race.
//
// Issued and read on the main thread, which is why there is no lock here. In a
// Flow this file disappears entirely, because flatMapLatest cancels the
// previous collection for you.
class RequestSequence {

    private var issued = 0L

    fun next() = ++issued

    fun isCurrent(generation: Long) = generation == issued
}

package com.androidinterview.search.results

// local is what the row renders as a cached badge, so the user can tell an
// instant local hit from a server ranked one.
data class Result(val id: String, val title: String, val local: Boolean)

// Local first, then the network on top. The local pass comes from a Room table
// of recent results and whatever slice of the catalogue is synced, and it
// paints in a frame instead of a round trip.
//
// The merge rule is the point. Server ranking wins for anything the server
// returned, because relevance is computed there with the data to do it with,
// and the local extras keep their place underneath rather than being
// interleaved by a score the client invented.
fun merge(local: List<Result>, remote: List<Result>): List<Result> {
    val seen = remote.mapTo(mutableSetOf()) { it.id }
    return remote + local.filterNot { it.id in seen }
}

// What the screen shows before a single letter is typed, which is the half of
// a search feature usually left until last. A Room table sits behind this,
// bounded, newest first, with a repeat moving to the top rather than appearing
// twice.
class RecentSearches(private val limit: Int) {

    private val queries = ArrayDeque<String>()

    fun record(query: String) {
        queries.remove(query)
        queries.addFirst(query)
        if (queries.size > limit) queries.removeLast()
    }

    fun all(): List<String> = queries.toList()
}