feat(card-browser): add filters to SearchHistory

The intention of Search History is that it will pre-populate
 chips in the UI with the previously selected values

These IDs are the planned 'first stage' of chips and
 match Anki Desktop's filters

Issue 18709

Author: david-allison

AnkiDroid/src/main/java/com/ichi2/anki/browser/SearchHistory.kt

@@ -16,14 +16,23 @@
 
 package com.ichi2.anki.browser
 
+import com.ichi2.anki.Flag
 import com.ichi2.anki.R
+import com.ichi2.anki.browser.search.CardState
+import com.ichi2.anki.libanki.DeckId
+import com.ichi2.anki.libanki.NoteTypeId
 import com.ichi2.anki.settings.Prefs
 import com.ichi2.anki.settings.PrefsRepository
+import kotlinx.serialization.EncodeDefault
+import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
 import kotlinx.serialization.json.Json
 import timber.log.Timber
 
+private typealias Tag = String
+
 /**
  * The user's past searches in the Card Browser.
  *
@@ -88,21 +97,48 @@ class SearchHistory(
     /**
      * An entry in the history of the card browser.
      * This is user-supplied, so may contain PII.
+     *
+     * Contains the minimal values needed for persistent serialization:
+     * Deck IDs are stored, rather than deck names. See [deckIds]
+     *
      * @see SearchHistory
      */
     // !! When updating this, consider equality in addRecent
+    // TODO: opt-in may no longer be needed in kotlinx-serialization 1.10.0
+    @OptIn(ExperimentalSerializationApi::class)
     @Serializable
     data class SearchHistoryEntry(
         @SerialName("q")
         val query: String,
+        // Use IDs so we can handle a rename.
+        // Tradeoff: a query to get the deck names is needed to produce a search string or display
+        // the selected deck name in the UI
+        @SerialName("did")
+        @EncodeDefault(EncodeDefault.Mode.NEVER)
+        val deckIds: List<DeckId> = emptyList(),
+        @SerialName("f")
+        @EncodeDefault(EncodeDefault.Mode.NEVER)
+        val flags: List<Flag> = emptyList(),
+        @SerialName("t")
+        @EncodeDefault(EncodeDefault.Mode.NEVER)
+        val tags: List<Tag> = emptyList(),
+        @SerialName("ntid")
+        @EncodeDefault(EncodeDefault.Mode.NEVER)
+        val noteTypes: List<NoteTypeId> = emptyList(),
+        @SerialName("s")
+        @EncodeDefault(EncodeDefault.Mode.NEVER)
+        val cardStates: List<CardState> = emptyList(),
     ) {
+        @Transient
+        private val allFilters = listOf(deckIds, flags, tags, noteTypes, cardStates)
+
         override fun toString() = query
 
         /**
          * Whether there is no set search - effectively a search for the default search:
          * `deck:*`
          */
-        fun isSearchEmpty() = query.isBlank()
+        fun isSearchEmpty() = query.isBlank() && allFilters.all { it.isEmpty() }
     }
 
     companion object {

AnkiDroid/src/test/java/com/ichi2/anki/browser/SearchHistoryTest.kt

@@ -18,9 +18,13 @@ package com.ichi2.anki.browser
 
 import androidx.annotation.CheckResult
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.ichi2.anki.Flag
 import com.ichi2.anki.R
 import com.ichi2.anki.RobolectricTest
 import com.ichi2.anki.browser.SearchHistory.SearchHistoryEntry
+import com.ichi2.anki.browser.search.CardState
+import com.ichi2.anki.libanki.DeckId
+import com.ichi2.anki.libanki.NoteTypeId
 import com.ichi2.anki.settings.Prefs
 import com.ichi2.testutils.getString
 import org.hamcrest.MatcherAssert.assertThat
@@ -118,7 +122,62 @@ class SearchHistoryTest : RobolectricTest() {
         // additional properties will be added; make sure we don't corrupt past entries
         addNumberedEntries(1)
         assertThat(readSearchHistoryRaw(), equalTo("""[{"q":"1"}]"""))
-        assertThat(history.entries.single().query, equalTo("1"))
+        with(history.entries.single()) {
+            assertThat(query, equalTo("1"))
+            assertThat(deckIds, empty())
+            assertThat(flags, empty())
+            assertThat(tags, empty())
+            assertThat(noteTypes, empty())
+            assertThat(cardStates, empty())
+        }
+    }
+
+    @Test
+    fun `v2 serialization is unchanged`() {
+        // additional properties will be added; make sure we don't corrupt past entries
+        history.addRecent(
+            SearchHistoryEntry(
+                query = "1",
+                deckIds = listOf(1, 2),
+                flags = listOf(Flag.RED, Flag.BLUE),
+                tags = listOf("Hello::World", "tag"),
+                noteTypes = listOf(3, 4),
+                cardStates =
+                    listOf(
+                        CardState.New,
+                        CardState.Learning,
+                        CardState.Review,
+                        CardState.Buried,
+                        CardState.Suspended,
+                    ),
+            ),
+        )
+        assertThat(
+            readSearchHistoryRaw(),
+            equalTo(
+                """[{"q":"1","did":[1,2],"f":[1,4],"t":["Hello::World","tag"],"ntid":[3,4],"s":[0,1,2,3,4]}]""",
+            ),
+        )
+
+        with(history.entries.single()) {
+            assertThat(query, equalTo("1"))
+            assertThat(deckIds, equalTo(listOf<DeckId>(1, 2)))
+            assertThat(flags, equalTo(listOf(Flag.RED, Flag.BLUE)))
+            assertThat(tags, equalTo(listOf("Hello::World", "tag")))
+            assertThat(noteTypes, equalTo(listOf<NoteTypeId>(3, 4)))
+            assertThat(
+                cardStates,
+                equalTo(
+                    listOf(
+                        CardState.New,
+                        CardState.Learning,
+                        CardState.Review,
+                        CardState.Buried,
+                        CardState.Suspended,
+                    ),
+                ),
+            )
+        }
     }
 
     @Test