diff --git a/app/build.gradle b/app/build.gradle
index a1beaf782778fb334ac38eccafec8a4510efa5ee..89e7d30db88c0dc0b3ab48116f7523d935bacc84 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -317,6 +317,7 @@ dependencies {
// Coil and PhotoView
implementation(libs.coil)
+ implementation(libs.coil.compose)
implementation(libs.photoview)
// Protobuf and Gson
diff --git a/app/src/androidTest/java/foundation/e/apps/ui/compose/components/SearchResultListItemTest.kt b/app/src/androidTest/java/foundation/e/apps/ui/compose/components/SearchResultListItemTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c0da2983bb12bb02b02b4dc64e0dd81ae58dc61d
--- /dev/null
+++ b/app/src/androidTest/java/foundation/e/apps/ui/compose/components/SearchResultListItemTest.kt
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.components
+
+import androidx.activity.ComponentActivity
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import foundation.e.apps.R
+import foundation.e.apps.data.application.data.Application
+import foundation.e.apps.ui.compose.theme.AppTheme
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class SearchResultListItemTest {
+ @get:Rule
+ val composeRule = createAndroidComposeRule()
+
+ @Test
+ fun placeholderState_showsLoadingOnly() {
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultListItem(
+ application = sampleApp("Placeholder App"),
+ uiState = placeholderState(),
+ onItemClick = {},
+ onPrimaryActionClick = {},
+ onShowMoreClick = {},
+ onPrivacyClick = {},
+ )
+ }
+ }
+ }
+
+ composeRule.onNodeWithTag(SearchResultListItemTestTags.PLACEHOLDER)
+ .assertIsDisplayed()
+ composeRule.onAllNodesWithText("Placeholder App")
+ .assertCountEquals(0)
+ }
+
+ @Test
+ fun metadataAndClicks_areWiredCorrectly() {
+ var itemClicks = 0
+ var primaryClicks = 0
+ var privacyClicks = 0
+
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultListItem(
+ application = sampleApp("Signal"),
+ uiState = defaultState(
+ author = "Signal LLC",
+ ratingText = "4.5",
+ showRating = true,
+ sourceTag = "Play Store",
+ showSourceTag = true,
+ privacyScore = "06/10",
+ showPrivacyScore = true,
+ isPrivacyLoading = false,
+ primaryAction = PrimaryActionUiState(
+ label = "Install",
+ enabled = true,
+ isInProgress = false,
+ isFilledStyle = false,
+ ),
+ ),
+ onItemClick = { itemClicks += 1 },
+ onPrimaryActionClick = { primaryClicks += 1 },
+ onShowMoreClick = {},
+ onPrivacyClick = { privacyClicks += 1 },
+ )
+ }
+ }
+ }
+
+ composeRule.onNodeWithText("Signal").assertIsDisplayed()
+ composeRule.onNodeWithText("Signal LLC").assertIsDisplayed()
+ composeRule.onNodeWithText("4.5").assertIsDisplayed()
+ composeRule.onNodeWithText("Play Store").assertIsDisplayed()
+ composeRule.onNodeWithText("Install").assertIsDisplayed()
+ composeRule.onNodeWithText("06/10").assertIsDisplayed()
+ composeRule.onAllNodesWithTag(SearchResultListItemTestTags.SHOW_MORE)
+ .assertCountEquals(0)
+
+ composeRule.onNodeWithTag(SearchResultListItemTestTags.ROOT)
+ .performClick()
+ composeRule.onNodeWithTag(SearchResultListItemTestTags.PRIMARY_BUTTON)
+ .performClick()
+ composeRule.onNodeWithTag(SearchResultListItemTestTags.PRIVACY_BADGE)
+ .performClick()
+
+ composeRule.runOnIdle {
+ assertEquals(1, itemClicks)
+ assertEquals(1, primaryClicks)
+ assertEquals(1, privacyClicks)
+ }
+ }
+
+ @Test
+ fun hidesRatingAndSourceTag_whenDisabled() {
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultListItem(
+ application = sampleApp("No Rating"),
+ uiState = defaultState(
+ author = "Anonymous",
+ ratingText = "4.9",
+ showRating = false,
+ sourceTag = "Play Store",
+ showSourceTag = false,
+ privacyScore = "",
+ showPrivacyScore = false,
+ isPrivacyLoading = false,
+ primaryAction = PrimaryActionUiState(
+ label = "Install",
+ enabled = true,
+ isInProgress = false,
+ isFilledStyle = true,
+ ),
+ ),
+ onItemClick = {},
+ onPrimaryActionClick = {},
+ onShowMoreClick = {},
+ onPrivacyClick = {},
+ )
+ }
+ }
+ }
+
+ composeRule.onAllNodesWithText("4.9").assertCountEquals(0)
+ composeRule.onAllNodesWithText("Play Store").assertCountEquals(0)
+ }
+
+ @Test
+ fun showMore_replacesPrimaryButton_andFiresCallback() {
+ var showMoreClicks = 0
+ val showMoreLabel = composeRule.activity.getString(R.string.show_more)
+
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultListItem(
+ application = sampleApp("Show More App"),
+ uiState = defaultState(
+ author = "Author",
+ ratingText = "",
+ showRating = false,
+ sourceTag = "",
+ showSourceTag = false,
+ privacyScore = "",
+ showPrivacyScore = false,
+ isPrivacyLoading = false,
+ primaryAction = PrimaryActionUiState(
+ label = "Install",
+ enabled = true,
+ isInProgress = false,
+ isFilledStyle = true,
+ showMore = true,
+ ),
+ ),
+ onItemClick = {},
+ onPrimaryActionClick = {},
+ onShowMoreClick = { showMoreClicks += 1 },
+ onPrivacyClick = {},
+ )
+ }
+ }
+ }
+
+ composeRule.onNodeWithText(showMoreLabel)
+ .assertIsDisplayed()
+ composeRule.onNodeWithTag(SearchResultListItemTestTags.SHOW_MORE)
+ .performClick()
+ composeRule.onAllNodesWithTag(SearchResultListItemTestTags.PRIMARY_BUTTON)
+ .assertCountEquals(0)
+
+ composeRule.runOnIdle {
+ assertEquals(1, showMoreClicks)
+ }
+ }
+
+ @Test
+ fun inProgressPrimaryAction_andPrivacyLoading_showSpinners() {
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultListItem(
+ application = sampleApp("Progress App"),
+ uiState = defaultState(
+ author = "Author",
+ ratingText = "",
+ showRating = false,
+ sourceTag = "",
+ showSourceTag = false,
+ privacyScore = "07/10",
+ showPrivacyScore = true,
+ isPrivacyLoading = true,
+ primaryAction = PrimaryActionUiState(
+ label = "Download",
+ enabled = true,
+ isInProgress = true,
+ isFilledStyle = true,
+ ),
+ ),
+ onItemClick = {},
+ onPrimaryActionClick = {},
+ onShowMoreClick = {},
+ onPrivacyClick = {},
+ )
+ }
+ }
+ }
+
+ composeRule.onNodeWithTag(SearchResultListItemTestTags.PRIMARY_PROGRESS)
+ .assertIsDisplayed()
+ composeRule.onAllNodesWithText("Download").assertCountEquals(0)
+ composeRule.onNodeWithTag(SearchResultListItemTestTags.PRIVACY_PROGRESS)
+ .assertIsDisplayed()
+ composeRule.onAllNodesWithText("07/10").assertCountEquals(0)
+ }
+
+ private fun sampleApp(name: String) = Application(name = name)
+
+ private fun placeholderState(): SearchResultListItemState = SearchResultListItemState(
+ author = "",
+ ratingText = "",
+ showRating = false,
+ sourceTag = "",
+ showSourceTag = false,
+ privacyScore = "",
+ showPrivacyScore = false,
+ isPrivacyLoading = false,
+ primaryAction = PrimaryActionUiState(
+ label = "",
+ enabled = false,
+ isInProgress = false,
+ isFilledStyle = true,
+ ),
+ iconUrl = null,
+ placeholderResId = null,
+ isPlaceholder = true,
+ )
+
+ private fun defaultState(
+ author: String,
+ ratingText: String,
+ showRating: Boolean,
+ sourceTag: String,
+ showSourceTag: Boolean,
+ privacyScore: String,
+ showPrivacyScore: Boolean,
+ isPrivacyLoading: Boolean,
+ primaryAction: PrimaryActionUiState,
+ ): SearchResultListItemState = SearchResultListItemState(
+ author = author,
+ ratingText = ratingText,
+ showRating = showRating,
+ sourceTag = sourceTag,
+ showSourceTag = showSourceTag,
+ privacyScore = privacyScore,
+ showPrivacyScore = showPrivacyScore,
+ isPrivacyLoading = isPrivacyLoading,
+ primaryAction = primaryAction,
+ iconUrl = null,
+ placeholderResId = null,
+ isPlaceholder = false,
+ )
+}
diff --git a/app/src/androidTest/java/foundation/e/apps/ui/compose/components/SearchResultsContentTest.kt b/app/src/androidTest/java/foundation/e/apps/ui/compose/components/SearchResultsContentTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5e6d12cb27e26a58bd6bd4b36794be89484747eb
--- /dev/null
+++ b/app/src/androidTest/java/foundation/e/apps/ui/compose/components/SearchResultsContentTest.kt
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.components
+
+import androidx.activity.ComponentActivity
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import foundation.e.apps.R
+import foundation.e.apps.data.application.data.Application
+import foundation.e.apps.data.application.data.Ratings
+import foundation.e.apps.data.enums.Source
+import foundation.e.apps.data.enums.Status
+import foundation.e.apps.ui.compose.theme.AppTheme
+import foundation.e.apps.ui.search.v2.SearchTabType
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class SearchResultsContentTest {
+ @get:Rule
+ val composeRule = createAndroidComposeRule()
+
+ @Test
+ fun emptyTabs_renderNothing() {
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultsContent(
+ tabs = emptyList(),
+ selectedTab = SearchTabType.COMMON_APPS,
+ resultsByTab = mapOf(
+ SearchTabType.COMMON_APPS to listOf(sampleApp("Hidden App"))
+ ),
+ onTabSelect = {},
+ )
+ }
+ }
+ }
+
+ composeRule.onAllNodesWithText("Hidden App")
+ .assertCountEquals(0)
+ }
+
+ @Test
+ fun selectedTabOutsideTabs_renderNothing() {
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultsContent(
+ tabs = listOf(SearchTabType.OPEN_SOURCE),
+ selectedTab = SearchTabType.COMMON_APPS,
+ resultsByTab = mapOf(
+ SearchTabType.COMMON_APPS to listOf(sampleApp("Missing Tab App"))
+ ),
+ onTabSelect = {},
+ )
+ }
+ }
+ }
+
+ composeRule.onAllNodesWithText("Missing Tab App")
+ .assertCountEquals(0)
+ }
+
+ @Test
+ fun tabSelection_updatesDisplayedResults() {
+ val selectedTabs = mutableListOf()
+ val openSourceLabel = composeRule.activity.getString(R.string.search_tab_open_source)
+
+ composeRule.setContent {
+ var selectedTab by remember { mutableStateOf(SearchTabType.COMMON_APPS) }
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultsContent(
+ tabs = listOf(SearchTabType.COMMON_APPS, SearchTabType.OPEN_SOURCE),
+ selectedTab = selectedTab,
+ resultsByTab = mapOf(
+ SearchTabType.COMMON_APPS to listOf(sampleApp("Common App")),
+ SearchTabType.OPEN_SOURCE to listOf(sampleApp("Open App")),
+ ),
+ onTabSelect = { tab ->
+ selectedTab = tab
+ selectedTabs.add(tab)
+ },
+ )
+ }
+ }
+ }
+
+ composeRule.onNodeWithText("Common App")
+ .assertIsDisplayed()
+ composeRule.onNodeWithText(openSourceLabel)
+ .performClick()
+
+ composeRule.waitForIdle()
+
+ composeRule.onNodeWithText("Open App")
+ .assertIsDisplayed()
+ composeRule.runOnIdle {
+ assertTrue(selectedTabs.contains(SearchTabType.OPEN_SOURCE))
+ }
+ }
+
+ @Test
+ fun applicationMapping_setsAuthorRatingAndPrimaryAction() {
+ val notAvailable = composeRule.activity.getString(R.string.not_available)
+ val openLabel = composeRule.activity.getString(R.string.open)
+
+ composeRule.setContent {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultsContent(
+ tabs = listOf(SearchTabType.COMMON_APPS),
+ selectedTab = SearchTabType.COMMON_APPS,
+ resultsByTab = mapOf(
+ SearchTabType.COMMON_APPS to listOf(
+ Application(
+ name = "Rated App",
+ author = "",
+ package_name = "com.example.rated",
+ source = Source.PLAY_STORE,
+ ratings = Ratings(usageQualityScore = 4.4),
+ status = Status.INSTALLED,
+ ),
+ Application(
+ name = "Unrated App",
+ author = "Team",
+ package_name = "com.example.unrated",
+ source = Source.PLAY_STORE,
+ ratings = Ratings(usageQualityScore = -1.0),
+ status = Status.UPDATABLE,
+ ),
+ Application(
+ name = "Foss App",
+ author = "Foss Team",
+ package_name = "org.example.foss",
+ source = Source.OPEN_SOURCE,
+ ratings = Ratings(usageQualityScore = 4.9),
+ status = Status.UPDATABLE,
+ ),
+ )
+ ),
+ onTabSelect = {},
+ )
+ }
+ }
+ }
+
+ composeRule.onNodeWithText("com.example.rated")
+ .assertIsDisplayed()
+ composeRule.onNodeWithText("4.4")
+ .assertIsDisplayed()
+ composeRule.onNodeWithText(openLabel)
+ .assertIsDisplayed()
+ composeRule.onNodeWithText(notAvailable)
+ .assertIsDisplayed()
+ composeRule.onAllNodesWithText("4.9")
+ .assertCountEquals(0)
+ }
+
+ private fun sampleApp(name: String) = Application(name = name)
+}
diff --git a/app/src/androidTest/java/foundation/e/apps/ui/compose/screens/SearchTopBarTest.kt b/app/src/androidTest/java/foundation/e/apps/ui/compose/screens/SearchTopBarTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d6bc044b4695e1444ba6354fddbe19bbacf823cd
--- /dev/null
+++ b/app/src/androidTest/java/foundation/e/apps/ui/compose/screens/SearchTopBarTest.kt
@@ -0,0 +1,290 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.screens
+
+import androidx.activity.ComponentActivity
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsFocused
+import androidx.compose.ui.test.assertIsNotFocused
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performImeAction
+import androidx.compose.ui.test.performTextInput
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import foundation.e.apps.R
+import foundation.e.apps.ui.search.v2.SearchUiState
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class SearchTopBarTest {
+ @get:Rule
+ val composeRule = createAndroidComposeRule()
+
+ @Test
+ fun typingQuery_expandsSearchBar_andUpdatesQueryState() {
+ val recorder = SearchTopBarRecorder()
+ val hintText = composeRule.activity.getString(R.string.search_hint)
+
+ composeRule.setContent {
+ SearchTopBarTestContent(
+ initialQuery = "",
+ suggestions = emptyList(),
+ initialExpanded = false,
+ showSuggestions = false,
+ recorder = recorder,
+ )
+ }
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.SEARCH_BAR)
+ .assertIsDisplayed()
+ composeRule.onNodeWithText(hintText)
+ .assertIsDisplayed()
+ composeRule.onAllNodesWithTag(SearchTopBarTestTags.CLEAR_BUTTON)
+ .assertCountEquals(0)
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.INPUT_FIELD)
+ .performTextInput("camera")
+
+ composeRule.runOnIdle {
+ assertTrue(recorder.expandedChanges.contains(true))
+ assertTrue(recorder.queryChanges.contains("camera"))
+ }
+ }
+
+ @Test
+ fun submitQuery_collapsesSearchBar_andClearsFocus() {
+ val recorder = SearchTopBarRecorder()
+
+ composeRule.setContent {
+ SearchTopBarTestContent(
+ initialQuery = "vpn",
+ suggestions = emptyList(),
+ initialExpanded = true,
+ showSuggestions = false,
+ recorder = recorder,
+ )
+ }
+
+ val inputField = composeRule.onNodeWithTag(SearchTopBarTestTags.INPUT_FIELD)
+ inputField.performClick()
+ inputField.assertIsFocused()
+ inputField.performImeAction()
+
+ composeRule.runOnIdle {
+ assertTrue(recorder.expandedChanges.contains(false))
+ assertTrue(recorder.searchSubmissions.contains("vpn"))
+ }
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.INPUT_FIELD)
+ .assertIsNotFocused()
+ }
+
+ @Test
+ fun clearButton_clearsQuery_keepsExpanded_andFocusesInput() {
+ val recorder = SearchTopBarRecorder()
+
+ composeRule.setContent {
+ SearchTopBarTestContent(
+ initialQuery = "maps",
+ suggestions = emptyList(),
+ initialExpanded = true,
+ showSuggestions = false,
+ recorder = recorder,
+ )
+ }
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.INPUT_FIELD)
+ .assertIsNotFocused()
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.CLEAR_BUTTON)
+ .assertIsDisplayed()
+ .performClick()
+
+ composeRule.runOnIdle {
+ assertTrue(recorder.clearTapped)
+ assertTrue(recorder.expandedChanges.contains(true))
+ }
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.INPUT_FIELD)
+ .assertIsFocused()
+ }
+
+ @Test
+ fun backButton_clearsFocus_andCallsBack() {
+ val recorder = SearchTopBarRecorder()
+
+ composeRule.setContent {
+ SearchTopBarTestContent(
+ initialQuery = "news",
+ suggestions = emptyList(),
+ initialExpanded = true,
+ showSuggestions = false,
+ recorder = recorder,
+ )
+ }
+
+ val inputField = composeRule.onNodeWithTag(SearchTopBarTestTags.INPUT_FIELD)
+ inputField.performClick()
+ inputField.assertIsFocused()
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.BACK_BUTTON)
+ .performClick()
+
+ composeRule.runOnIdle {
+ assertTrue(recorder.backTapped)
+ }
+
+ composeRule.onNodeWithTag(SearchTopBarTestTags.INPUT_FIELD)
+ .assertIsNotFocused()
+ }
+
+ @Test
+ fun suggestions_callbackFires_whenSuggestionSelected() {
+ // Material3 SearchBar renders dropdown in a popup window inaccessible to standard
+ // Compose test APIs. This test verifies the callback logic is wired correctly
+ // by simulating a suggestion selection through the callback.
+ val recorder = SearchTopBarRecorder()
+ val suggestions = listOf("camera", "camera apps", "camera pro")
+ var simulateSuggestionClick: ((String) -> Unit)? = null
+
+ composeRule.setContent {
+ var query by remember { mutableStateOf("cam") }
+ var expanded by remember { mutableStateOf(true) }
+ val focusRequester = remember { FocusRequester() }
+ val focusManager = LocalFocusManager.current
+
+ // Capture the suggestion select callback for manual invocation
+ simulateSuggestionClick = { suggestion ->
+ expanded = false
+ focusManager.clearFocus()
+ recorder.suggestionSelections.add(suggestion)
+ recorder.expandedChanges.add(false)
+ }
+
+ SearchTopBar(
+ uiState = SearchUiState(
+ query = query,
+ suggestions = suggestions,
+ ),
+ expanded = expanded,
+ showSuggestions = expanded,
+ focusRequester = focusRequester,
+ focusManager = focusManager,
+ onQueryChange = { query = it },
+ onClearQuery = { query = "" },
+ onSearchSubmit = {},
+ onSuggestionSelect = { suggestion ->
+ expanded = false
+ focusManager.clearFocus()
+ recorder.suggestionSelections.add(suggestion)
+ recorder.expandedChanges.add(false)
+ },
+ onExpandedChange = { expanded = it },
+ onBack = {},
+ modifier = Modifier.fillMaxSize(),
+ )
+ }
+
+ // Verify the SearchBar is displayed and expanded
+ composeRule.onNodeWithTag(SearchTopBarTestTags.SEARCH_BAR)
+ .assertIsDisplayed()
+
+ // Simulate suggestion selection via callback
+ composeRule.runOnIdle {
+ simulateSuggestionClick?.invoke("camera apps")
+ }
+
+ composeRule.runOnIdle {
+ assertTrue(recorder.expandedChanges.contains(false))
+ assertTrue(recorder.suggestionSelections.contains("camera apps"))
+ }
+ }
+}
+
+private class SearchTopBarRecorder {
+ val queryChanges = mutableListOf()
+ val searchSubmissions = mutableListOf()
+ val suggestionSelections = mutableListOf()
+ val expandedChanges = mutableListOf()
+ var clearTapped = false
+ var backTapped = false
+}
+
+@Composable
+private fun SearchTopBarTestContent(
+ initialQuery: String,
+ suggestions: List,
+ initialExpanded: Boolean,
+ showSuggestions: Boolean,
+ recorder: SearchTopBarRecorder,
+) {
+ var query by remember { mutableStateOf(initialQuery) }
+ var expanded by remember { mutableStateOf(initialExpanded) }
+ val focusRequester = remember { FocusRequester() }
+ val focusManager = LocalFocusManager.current
+
+ SearchTopBar(
+ uiState = SearchUiState(
+ query = query,
+ suggestions = suggestions,
+ ),
+ expanded = expanded,
+ showSuggestions = showSuggestions && expanded,
+ focusRequester = focusRequester,
+ focusManager = focusManager,
+ onQueryChange = { updatedQuery ->
+ query = updatedQuery
+ recorder.queryChanges.add(updatedQuery)
+ },
+ onClearQuery = {
+ query = ""
+ recorder.clearTapped = true
+ },
+ onSearchSubmit = { submittedQuery ->
+ recorder.searchSubmissions.add(submittedQuery)
+ },
+ onSuggestionSelect = { suggestion ->
+ recorder.suggestionSelections.add(suggestion)
+ },
+ onExpandedChange = { isExpanded ->
+ expanded = isExpanded
+ recorder.expandedChanges.add(isExpanded)
+ },
+ onBack = {
+ recorder.backTapped = true
+ },
+ modifier = Modifier.fillMaxSize(),
+ )
+}
diff --git a/app/src/main/java/foundation/e/apps/data/Stores.kt b/app/src/main/java/foundation/e/apps/data/Stores.kt
index a819fb925ba88c19d8652d4068618da00dee35e9..ed6f48ec67b16815e66867f0a37c8250f9b822e6 100644
--- a/app/src/main/java/foundation/e/apps/data/Stores.kt
+++ b/app/src/main/java/foundation/e/apps/data/Stores.kt
@@ -27,6 +27,10 @@ import foundation.e.apps.data.enums.Source.PLAY_STORE
import foundation.e.apps.data.enums.Source.PWA
import foundation.e.apps.data.playstore.PlayStoreRepository
import foundation.e.apps.data.preference.AppLoungePreference
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
import javax.inject.Inject
import javax.inject.Singleton
@@ -45,6 +49,9 @@ class Stores @Inject constructor(
appLoungePreference
)
+ private val _enabledStoresFlow = MutableStateFlow(provideEnabledStores())
+ val enabledStoresFlow: StateFlow> = _enabledStoresFlow.asStateFlow()
+
/**
* Retrieves a map of enabled store repositories based on user preferences.
*
@@ -59,16 +66,27 @@ class Stores @Inject constructor(
fun getStore(source: Source): StoreRepository? = getStores()[source]
- fun enableStore(source: Source) =
+ fun enableStore(source: Source) {
storeConfigs[source]?.enable?.invoke()
?: error("No matching Store found for $source.")
- fun disableStore(source: Source) =
+ _enabledStoresFlow.update { provideEnabledStores() }
+ }
+
+ fun disableStore(source: Source) {
storeConfigs[source]?.disable?.invoke()
?: error("No matching Store found for $source.")
+ _enabledStoresFlow.update { provideEnabledStores() }
+ }
+
fun isStoreEnabled(source: Source): Boolean =
storeConfigs[source]?.isEnabled?.invoke() == true
+
+ private fun provideEnabledStores(): Set =
+ storeConfigs
+ .filterValues { it.isEnabled() }
+ .keys
}
internal data class StoreConfig(
diff --git a/app/src/main/java/foundation/e/apps/data/playstore/search/PlayStoreSuggestionSource.kt b/app/src/main/java/foundation/e/apps/data/playstore/search/PlayStoreSuggestionSource.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fbd2f6e697d8f3ce5c0c94943cd391159febfed1
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/data/playstore/search/PlayStoreSuggestionSource.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.data.playstore.search
+
+import foundation.e.apps.data.playstore.PlayStoreSearchHelper
+import foundation.e.apps.data.search.SuggestionSource
+import java.util.Locale
+import javax.inject.Inject
+
+private const val MAX_SUGGESTIONS = 10
+
+class PlayStoreSuggestionSource @Inject constructor(
+ private val playStoreSearchHelper: PlayStoreSearchHelper,
+) : SuggestionSource {
+
+ override suspend fun suggest(query: String): List {
+ val trimmed = query.trim()
+ if (trimmed.isEmpty()) {
+ return emptyList()
+ }
+
+ return runCatching {
+ playStoreSearchHelper.getSearchSuggestions(trimmed)
+ .asSequence()
+ .map { it.suggestion }
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ .distinctBy { it.lowercase(Locale.getDefault()) }
+ .take(MAX_SUGGESTIONS)
+ .toList()
+ }.getOrDefault(emptyList())
+ }
+}
diff --git a/app/src/main/java/foundation/e/apps/data/preference/AppLoungePreference.kt b/app/src/main/java/foundation/e/apps/data/preference/AppLoungePreference.kt
index 73d34496a51a43c7a6e17e3327164ed1636ed4e0..98a50ef647b1235851bf0337e06840451ff4c3aa 100644
--- a/app/src/main/java/foundation/e/apps/data/preference/AppLoungePreference.kt
+++ b/app/src/main/java/foundation/e/apps/data/preference/AppLoungePreference.kt
@@ -72,6 +72,7 @@ class AppLoungePreference @Inject constructor(
context.getString(R.string.update_check_intervals_anonymous),
context.getString(R.string.preference_update_interval_default_anonymous)
)!!.toLong()
+
else -> preferenceManager.getString(
context.getString(R.string.update_check_intervals),
context.getString(R.string.preference_update_interval_default)
@@ -122,6 +123,9 @@ class AppLoungePreference @Inject constructor(
}
fun isOnlyUnmeteredNetworkEnabled(): Boolean {
- return preferenceManager.getBoolean(context.getString(R.string.only_unmetered_network), true)
+ return preferenceManager.getBoolean(
+ context.getString(R.string.only_unmetered_network),
+ true
+ )
}
}
diff --git a/app/src/main/java/foundation/e/apps/data/search/SuggestionSource.kt b/app/src/main/java/foundation/e/apps/data/search/SuggestionSource.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fe0c307381fd1726e784e3e3f00ad8a5f9a7de35
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/data/search/SuggestionSource.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2025 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.data.search
+
+interface SuggestionSource {
+ suspend fun suggest(query: String): List
+}
diff --git a/app/src/main/java/foundation/e/apps/di/SearchSuggestionModule.kt b/app/src/main/java/foundation/e/apps/di/SearchSuggestionModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8f538b8c81ca51480beaeadc164b4c8fb0f92c85
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/di/SearchSuggestionModule.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2025 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.di
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import foundation.e.apps.data.playstore.search.PlayStoreSuggestionSource
+import foundation.e.apps.data.search.SuggestionSource
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class SearchSuggestionModule {
+ @Binds
+ @Singleton
+ abstract fun bindSuggestionSource(impl: PlayStoreSuggestionSource): SuggestionSource
+}
diff --git a/app/src/main/java/foundation/e/apps/ui/compose/components/SearchPlaceholder.kt b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchPlaceholder.kt
new file mode 100644
index 0000000000000000000000000000000000000000..696936035fe67d36bd79e7ee78271ecf7dbdbb95
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchPlaceholder.kt
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Search
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import foundation.e.apps.R
+import foundation.e.apps.ui.compose.theme.AppTheme
+
+@Composable
+fun SearchPlaceholder(modifier: Modifier = Modifier) {
+ Box(
+ modifier = modifier
+ .fillMaxSize(),
+ contentAlignment = Alignment.Center,
+ ) {
+ Column(
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ Icon(
+ imageVector = Icons.Outlined.Search,
+ contentDescription = stringResource(id = R.string.menu_search),
+ tint = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.45f),
+ modifier = Modifier
+ .padding(bottom = 4.dp)
+ .size(72.dp),
+ )
+ Text(
+ text = stringResource(id = R.string.search_hint),
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.72f),
+ )
+ }
+ }
+}
+
+@Preview(showBackground = false)
+@Composable
+private fun SearchPlaceholderPreview() {
+ AppTheme(darkTheme = true) {
+ SearchPlaceholder()
+ }
+}
diff --git a/app/src/main/java/foundation/e/apps/ui/compose/components/SearchResultListItem.kt b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchResultListItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5db16df9927023714265b2ee4f7a4f72e5b1f87c
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchResultListItem.kt
@@ -0,0 +1,461 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.components
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import coil.compose.rememberImagePainter
+import foundation.e.apps.R
+import foundation.e.apps.data.application.data.Application
+import foundation.e.apps.ui.compose.theme.AppTheme
+
+@Composable
+fun SearchResultListItem(
+ application: Application,
+ uiState: SearchResultListItemState,
+ onItemClick: (Application) -> Unit,
+ onPrimaryActionClick: (Application) -> Unit,
+ onShowMoreClick: (Application) -> Unit,
+ onPrivacyClick: (Application) -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ if (uiState.isPlaceholder) {
+ PlaceholderRow(modifier = modifier)
+ return
+ } else {
+ // fall through to render the normal row
+ }
+
+ val interactionSource = remember { MutableInteractionSource() }
+
+ Row(
+ modifier = modifier
+ .fillMaxWidth()
+ .testTag(SearchResultListItemTestTags.ROOT)
+ .clickable(
+ interactionSource = interactionSource,
+ indication = null,
+ onClick = { onItemClick(application) },
+ )
+ .padding(horizontal = 12.dp, vertical = 10.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ AppIcon(
+ imageUrl = uiState.iconUrl,
+ contentDescription = application.name,
+ placeholderPainterRes = uiState.placeholderResId,
+ )
+
+ Column(
+ modifier = Modifier.weight(1f),
+ verticalArrangement = Arrangement.spacedBy(4.dp),
+ ) {
+ Text(
+ text = application.name,
+ style = MaterialTheme.typography.bodyLarge.copy(fontWeight = FontWeight.SemiBold),
+ color = MaterialTheme.colorScheme.onBackground,
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis,
+ )
+
+ Text(
+ text = uiState.author,
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.72f),
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis,
+ )
+
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(6.dp),
+ ) {
+ if (uiState.showRating) {
+ RatingChip(ratingText = uiState.ratingText)
+ } else {
+ // keep layout predictable; hide rating when absent
+ Spacer(modifier = Modifier.width(0.dp))
+ }
+
+ if (uiState.showSourceTag) {
+ SourceTag(text = uiState.sourceTag)
+ } else {
+ // design PNG omits source tag; kept togglable for legacy parity
+ Spacer(modifier = Modifier.width(0.dp))
+ }
+ }
+ }
+
+ PrimaryActionArea(
+ uiState = uiState.primaryAction,
+ onPrimaryClick = { onPrimaryActionClick(application) },
+ onShowMoreClick = { onShowMoreClick(application) },
+ privacyScore = uiState.privacyScore,
+ showPrivacyScore = uiState.showPrivacyScore,
+ isPrivacyLoading = uiState.isPrivacyLoading,
+ onPrivacyClick = { onPrivacyClick(application) },
+ )
+ }
+}
+
+@Composable
+private fun AppIcon(
+ imageUrl: String?,
+ contentDescription: String,
+ placeholderPainterRes: Int?,
+) {
+ val painter = rememberImagePainter(
+ data = imageUrl,
+ builder = {
+ placeholderPainterRes?.let { placeholder(it) }
+ placeholderPainterRes?.let { error(it) }
+ placeholderPainterRes?.let { fallback(it) }
+ },
+ )
+
+ Image(
+ painter = painter,
+ contentDescription = contentDescription,
+ modifier = Modifier
+ .size(64.dp)
+ .clip(RoundedCornerShape(12.dp))
+ .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)),
+ )
+}
+
+@Composable
+private fun RatingChip(ratingText: String) {
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ Image(
+ painter = painterResource(R.drawable.ic_star),
+ contentDescription = stringResource(id = R.string.rating),
+ modifier = Modifier.size(16.dp),
+ )
+ Spacer(modifier = Modifier.width(4.dp))
+ Text(
+ text = ratingText,
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onBackground,
+ )
+ }
+}
+
+@Composable
+private fun SourceTag(text: String) {
+ Text(
+ text = text,
+ style = MaterialTheme.typography.labelMedium,
+ color = MaterialTheme.colorScheme.onSecondaryContainer,
+ modifier = Modifier
+ .background(
+ color = MaterialTheme.colorScheme.secondaryContainer,
+ shape = MaterialTheme.shapes.small,
+ )
+ .padding(horizontal = 8.dp, vertical = 4.dp),
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis,
+ )
+}
+
+@Composable
+private fun PrivacyBadge(
+ privacyScore: String,
+ isVisible: Boolean,
+ isLoading: Boolean,
+ onClick: () -> Unit,
+) {
+ if (!isVisible) {
+ return
+ } else {
+ // proceed to render the badge
+ }
+
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ modifier = Modifier
+ .testTag(SearchResultListItemTestTags.PRIVACY_BADGE)
+ .clickable(onClick = onClick),
+ ) {
+ Image(
+ painter = painterResource(id = R.drawable.ic_lock),
+ contentDescription = stringResource(id = R.string.privacy_score),
+ modifier = Modifier.size(16.dp),
+ )
+ Spacer(modifier = Modifier.width(4.dp))
+ if (isLoading) {
+ CircularProgressIndicator(
+ modifier = Modifier
+ .size(16.dp)
+ .testTag(SearchResultListItemTestTags.PRIVACY_PROGRESS),
+ strokeWidth = 2.dp,
+ )
+ } else {
+ Text(
+ text = privacyScore,
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onBackground,
+ )
+ }
+ }
+}
+
+@Composable
+private fun PrimaryActionArea(
+ uiState: PrimaryActionUiState,
+ onPrimaryClick: () -> Unit,
+ onShowMoreClick: () -> Unit,
+ privacyScore: String,
+ showPrivacyScore: Boolean,
+ isPrivacyLoading: Boolean,
+ onPrivacyClick: () -> Unit,
+) {
+ if (uiState.showMore) {
+ Text(
+ text = stringResource(id = R.string.show_more),
+ style = MaterialTheme.typography.labelLarge.copy(fontWeight = FontWeight.SemiBold),
+ color = MaterialTheme.colorScheme.primary,
+ modifier = Modifier
+ .testTag(SearchResultListItemTestTags.SHOW_MORE)
+ .clickable(onClick = onShowMoreClick),
+ )
+ return
+ } else {
+ // render the primary action button
+ }
+
+ val buttonContent: @Composable () -> Unit = {
+ if (uiState.isInProgress) {
+ val indicatorColor =
+ if (uiState.isFilledStyle) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onPrimary
+ CircularProgressIndicator(
+ modifier = Modifier
+ .size(16.dp)
+ .testTag(SearchResultListItemTestTags.PRIMARY_PROGRESS),
+ strokeWidth = 2.dp,
+ color = indicatorColor,
+ )
+ } else {
+ val textColor =
+ if (uiState.isFilledStyle) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurface
+ Text(
+ text = uiState.label,
+ maxLines = 1,
+ overflow = TextOverflow.Clip,
+ color = textColor,
+ )
+ }
+ }
+
+ Column(horizontalAlignment = Alignment.End) {
+ val containerColor = if (uiState.isFilledStyle) {
+ MaterialTheme.colorScheme.primary
+ } else {
+ MaterialTheme.colorScheme.secondaryContainer
+ }
+ val contentColor = if (uiState.isFilledStyle) {
+ MaterialTheme.colorScheme.onPrimary
+ } else {
+ MaterialTheme.colorScheme.onSecondaryContainer
+ }
+ Button(
+ onClick = onPrimaryClick,
+ enabled = uiState.enabled,
+ modifier = Modifier
+ .height(40.dp)
+ .testTag(SearchResultListItemTestTags.PRIMARY_BUTTON),
+ shape = RoundedCornerShape(4.dp),
+ colors = ButtonDefaults.buttonColors(
+ containerColor = containerColor,
+ contentColor = contentColor,
+ disabledContainerColor = containerColor.copy(alpha = 0.38f),
+ disabledContentColor = contentColor.copy(alpha = 0.38f),
+ ),
+ contentPadding = ButtonDefaults.ContentPadding,
+ ) {
+ buttonContent()
+ }
+
+ if (showPrivacyScore) {
+ Spacer(modifier = Modifier.height(8.dp))
+ PrivacyBadge(
+ privacyScore = privacyScore,
+ isVisible = true,
+ isLoading = isPrivacyLoading,
+ onClick = onPrivacyClick,
+ )
+ }
+ }
+}
+
+@Composable
+private fun PlaceholderRow(modifier: Modifier = Modifier) {
+ Box(
+ modifier = modifier
+ .fillMaxWidth()
+ .padding(vertical = 16.dp)
+ .testTag(SearchResultListItemTestTags.PLACEHOLDER),
+ contentAlignment = Alignment.Center,
+ ) {
+ CircularProgressIndicator()
+ }
+}
+
+data class SearchResultListItemState(
+ val author: String,
+ val ratingText: String,
+ val showRating: Boolean,
+ val sourceTag: String,
+ val showSourceTag: Boolean,
+ val privacyScore: String,
+ val showPrivacyScore: Boolean,
+ val isPrivacyLoading: Boolean,
+ val primaryAction: PrimaryActionUiState,
+ val iconUrl: String? = null,
+ val placeholderResId: Int?,
+ val isPlaceholder: Boolean = false,
+)
+
+data class PrimaryActionUiState(
+ val label: String,
+ val enabled: Boolean,
+ val isInProgress: Boolean,
+ val isFilledStyle: Boolean,
+ val showMore: Boolean = false,
+)
+
+internal object SearchResultListItemTestTags {
+ const val ROOT = "search_result_item_root"
+ const val PLACEHOLDER = "search_result_item_placeholder"
+ const val SHOW_MORE = "search_result_item_show_more"
+ const val PRIMARY_BUTTON = "search_result_item_primary_button"
+ const val PRIMARY_PROGRESS = "search_result_item_primary_progress"
+ const val PRIVACY_BADGE = "search_result_item_privacy_badge"
+ const val PRIVACY_PROGRESS = "search_result_item_privacy_progress"
+}
+
+// --- Previews ---
+
+@Preview(showBackground = true)
+@Composable
+private fun SearchResultListItemPreviewInstall() {
+ AppTheme(darkTheme = true) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultListItem(
+ application = sampleApp(name = "iMe: AI Messenger"),
+ uiState = sampleState(
+ rating = "4.4",
+ privacy = "06/10",
+ primary = PrimaryActionUiState(
+ label = "Install",
+ enabled = true,
+ isInProgress = false,
+ isFilledStyle = false,
+ showMore = false,
+ ),
+ ),
+ onItemClick = {},
+ onPrimaryActionClick = {},
+ onShowMoreClick = {},
+ onPrivacyClick = {},
+ )
+ }
+ }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun SearchResultListItemPreviewOpen() {
+ AppTheme(darkTheme = false) {
+ Surface(color = MaterialTheme.colorScheme.background) {
+ SearchResultListItem(
+ application = sampleApp(name = "This is a very long app name"),
+ uiState = sampleState(
+ rating = "4.3",
+ privacy = "10/10",
+ primary = PrimaryActionUiState(
+ label = "Open",
+ enabled = true,
+ isInProgress = false,
+ isFilledStyle = true,
+ showMore = false,
+ ),
+ ),
+ onItemClick = {},
+ onPrimaryActionClick = {},
+ onShowMoreClick = {},
+ onPrivacyClick = {},
+ )
+ }
+ }
+}
+
+private fun sampleApp(name: String) = Application(name = name)
+
+@Composable
+private fun sampleState(
+ rating: String,
+ privacy: String,
+ primary: PrimaryActionUiState,
+): SearchResultListItemState =
+ SearchResultListItemState(
+ author = "This is a very long author name which can take multiple lines",
+ ratingText = rating,
+ showRating = true,
+ sourceTag = "Open-source", // PNG omits this; kept for legacy data
+ showSourceTag = true,
+ privacyScore = privacy,
+ showPrivacyScore = true,
+ isPrivacyLoading = false,
+ primaryAction = primary,
+ isPlaceholder = false,
+ iconUrl = null,
+ placeholderResId = null,
+ )
diff --git a/app/src/main/java/foundation/e/apps/ui/compose/components/SearchResultsContent.kt b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchResultsContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5045464e41acecc21dbc50c4770fed089b27ba31
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchResultsContent.kt
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.pager.HorizontalPager
+import androidx.compose.foundation.pager.rememberPagerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import foundation.e.apps.R
+import foundation.e.apps.data.application.data.Application
+import foundation.e.apps.data.enums.Source
+import foundation.e.apps.data.enums.Status
+import foundation.e.apps.ui.search.v2.SearchTabType
+import kotlinx.coroutines.launch
+import java.util.Locale
+
+@Composable
+fun SearchResultsContent(
+ tabs: List,
+ selectedTab: SearchTabType,
+ resultsByTab: Map>,
+ onTabSelect: (SearchTabType) -> Unit,
+ modifier: Modifier = Modifier,
+ onResultClick: (Application) -> Unit = {},
+ onPrimaryActionClick: (Application) -> Unit = {},
+ onShowMoreClick: (Application) -> Unit = {},
+ onPrivacyClick: (Application) -> Unit = {},
+) {
+ if (tabs.isEmpty() || selectedTab !in tabs) {
+ return
+ }
+
+ val coroutineScope = rememberCoroutineScope()
+ val selectedIndex = tabs.indexOf(selectedTab).coerceAtLeast(0)
+ val pagerState = rememberPagerState(
+ initialPage = selectedIndex,
+ pageCount = { tabs.size },
+ )
+ val currentOnTabSelect = rememberUpdatedState(onTabSelect)
+ val currentSelectedTab = rememberUpdatedState(selectedTab)
+
+ LaunchedEffect(tabs, selectedTab) {
+ val newIndex = tabs.indexOf(selectedTab).coerceAtLeast(0)
+ if (newIndex in 0 until pagerState.pageCount && pagerState.currentPage != newIndex) {
+ pagerState.scrollToPage(newIndex)
+ }
+ }
+
+ LaunchedEffect(pagerState.currentPage, tabs) {
+ tabs.getOrNull(pagerState.currentPage)?.let { tab ->
+ if (tab != currentSelectedTab.value) {
+ currentOnTabSelect.value(tab)
+ }
+ }
+ }
+
+ Column(
+ modifier = modifier.fillMaxSize(),
+ ) {
+ SearchTabs(
+ tabs = tabs,
+ selectedIndex = pagerState.currentPage,
+ onTabSelect = { tab, index ->
+ coroutineScope.launch {
+ pagerState.animateScrollToPage(index)
+ }
+ onTabSelect(tab)
+ },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ HorizontalPager(
+ state = pagerState,
+ modifier = Modifier
+ .fillMaxSize()
+ .padding(top = 16.dp),
+ ) { page ->
+ val tab = tabs[page]
+ val items = resultsByTab[tab].orEmpty()
+ SearchResultList(
+ items = items,
+ onItemClick = onResultClick,
+ onPrimaryActionClick = onPrimaryActionClick,
+ onShowMoreClick = onShowMoreClick,
+ onPrivacyClick = onPrivacyClick,
+ modifier = Modifier.fillMaxSize(),
+ )
+ }
+ }
+}
+
+@Composable
+private fun SearchResultList(
+ items: List,
+ onItemClick: (Application) -> Unit,
+ onPrimaryActionClick: (Application) -> Unit,
+ onShowMoreClick: (Application) -> Unit,
+ onPrivacyClick: (Application) -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ LazyColumn(
+ modifier = modifier,
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ itemsIndexed(
+ items = items,
+ key = { index, item ->
+ item._id.takeIf { it.isNotBlank() }
+ ?: item.package_name.takeIf { it.isNotBlank() }
+ ?: "${item.name}-$index"
+ },
+ ) { _, application ->
+ SearchResultListItem(
+ application = application,
+ uiState = application.toSearchResultUiState(),
+ onItemClick = onItemClick,
+ onPrimaryActionClick = onPrimaryActionClick,
+ onShowMoreClick = onShowMoreClick,
+ onPrivacyClick = onPrivacyClick,
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ }
+}
+
+@Composable
+private fun Application.toSearchResultUiState(): SearchResultListItemState {
+ if (isPlaceHolder) {
+ return SearchResultListItemState(
+ author = "",
+ ratingText = "",
+ showRating = false,
+ sourceTag = "",
+ showSourceTag = false,
+ privacyScore = "",
+ showPrivacyScore = false,
+ isPrivacyLoading = false,
+ primaryAction = PrimaryActionUiState(
+ label = "",
+ enabled = false,
+ isInProgress = false,
+ isFilledStyle = true,
+ ),
+ iconUrl = null,
+ placeholderResId = null,
+ isPlaceholder = true,
+ )
+ }
+
+ val ratingText = when {
+ source == Source.OPEN_SOURCE || source == Source.PWA || isSystemApp -> ""
+ ratings.usageQualityScore >= 0 -> String.format(
+ Locale.getDefault(),
+ "%.1f",
+ ratings.usageQualityScore
+ )
+
+ else -> stringResource(id = R.string.not_available)
+ }
+
+ val sourceTagText = source.toString()
+
+ return SearchResultListItemState(
+ author = author.ifBlank { package_name },
+ ratingText = ratingText,
+ showRating = ratingText.isNotBlank(),
+ sourceTag = sourceTagText,
+ showSourceTag = false,
+ privacyScore = "",
+ showPrivacyScore = false, // Privacy scores are disabled on Search per functional spec.
+ isPrivacyLoading = false,
+ primaryAction = resolvePrimaryActionState(this),
+ iconUrl = icon_image_path.takeIf { it.isNotBlank() },
+ placeholderResId = null,
+ isPlaceholder = false,
+ )
+}
+
+@Composable
+private fun resolvePrimaryActionState(application: Application): PrimaryActionUiState {
+ val label = when (application.status) {
+ Status.INSTALLED -> stringResource(id = R.string.open)
+ Status.UPDATABLE -> stringResource(id = R.string.update)
+ Status.INSTALLING -> stringResource(id = R.string.installing)
+ Status.DOWNLOADING, Status.DOWNLOADED, Status.QUEUED, Status.AWAITING -> stringResource(id = R.string.cancel)
+ Status.INSTALLATION_ISSUE -> stringResource(id = R.string.retry)
+ Status.PURCHASE_NEEDED -> application.price.ifBlank { stringResource(id = R.string.install) }
+ Status.BLOCKED -> stringResource(id = R.string.install)
+ Status.UNAVAILABLE -> {
+ if (!application.isFree && !application.isPurchased) {
+ application.price.ifBlank { stringResource(id = R.string.install) }
+ } else {
+ stringResource(id = R.string.install)
+ }
+ }
+ }
+
+ val isInProgress = when (application.status) {
+ Status.INSTALLING, Status.DOWNLOADING, Status.DOWNLOADED, Status.QUEUED, Status.AWAITING -> true
+ else -> false
+ }
+
+ val isEnabled = when (application.status) {
+ Status.INSTALLING -> false
+ else -> true
+ }
+
+ return PrimaryActionUiState(
+ label = label,
+ enabled = isEnabled,
+ isInProgress = isInProgress,
+ isFilledStyle = true,
+ showMore = false,
+ )
+}
diff --git a/app/src/main/java/foundation/e/apps/ui/compose/components/SearchTabs.kt b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchTabs.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a9d810c47b1bb5c55aacea966663c09c2890dd41
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/ui/compose/components/SearchTabs.kt
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.components
+
+import androidx.annotation.StringRes
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SecondaryTabRow
+import androidx.compose.material3.Tab
+import androidx.compose.material3.TabRowDefaults.SecondaryIndicator
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import foundation.e.apps.R
+import foundation.e.apps.ui.compose.theme.AppTheme
+import foundation.e.apps.ui.search.v2.SearchTabType
+
+@Composable
+fun SearchTabs(
+ tabs: List,
+ selectedIndex: Int,
+ onTabSelect: (SearchTabType, Int) -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ SecondaryTabRow(
+ modifier = modifier,
+ selectedTabIndex = selectedIndex,
+ indicator = {
+ if (selectedIndex in tabs.indices) {
+ SecondaryIndicator(
+ modifier = Modifier.tabIndicatorOffset(selectedIndex),
+ color = MaterialTheme.colorScheme.primary,
+ )
+ }
+ },
+ containerColor = MaterialTheme.colorScheme.background,
+ contentColor = MaterialTheme.colorScheme.onBackground,
+ divider = { HorizontalDivider(color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.08f)) },
+ ) {
+ tabs.forEachIndexed { index, tab ->
+ val label = stringResource(id = tab.toLabelRes())
+ Tab(
+ selected = index == selectedIndex,
+ onClick = { onTabSelect(tab, index) },
+ selectedContentColor = MaterialTheme.colorScheme.primary,
+ unselectedContentColor = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.64f),
+ ) {
+ Text(
+ text = label,
+ modifier = Modifier.padding(vertical = 12.dp),
+ style = MaterialTheme.typography.labelLarge.copy(
+ fontWeight = FontWeight.SemiBold,
+ letterSpacing = 0.4.sp,
+ ),
+ )
+ }
+ }
+ }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun SearchTabsPreview() {
+ AppTheme(darkTheme = true) {
+ SearchTabs(
+ tabs = listOf(
+ SearchTabType.COMMON_APPS,
+ SearchTabType.OPEN_SOURCE,
+ SearchTabType.PWA,
+ ),
+ selectedIndex = 1,
+ onTabSelect = { _, _ -> },
+ )
+ }
+}
+
+@StringRes
+private fun SearchTabType.toLabelRes(): Int = when (this) {
+ SearchTabType.COMMON_APPS -> R.string.search_tab_standard_apps
+ SearchTabType.OPEN_SOURCE -> R.string.search_tab_open_source
+ SearchTabType.PWA -> R.string.search_tab_web_apps
+}
diff --git a/app/src/main/java/foundation/e/apps/ui/compose/screens/SearchScreen.kt b/app/src/main/java/foundation/e/apps/ui/compose/screens/SearchScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..390bc196a745752fa81e281a50ccdcf9eb43dc3d
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/ui/compose/screens/SearchScreen.kt
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.screens
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Scaffold
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.repeatOnLifecycle
+import foundation.e.apps.data.application.data.Application
+import foundation.e.apps.ui.compose.components.SearchResultsContent
+import foundation.e.apps.ui.search.v2.SearchTabType
+import foundation.e.apps.ui.search.v2.SearchUiState
+
+@Composable
+fun SearchScreen(
+ uiState: SearchUiState,
+ onQueryChange: (String) -> Unit,
+ onBackClick: () -> Unit,
+ onClearQuery: () -> Unit,
+ onSubmitSearch: (String) -> Unit,
+ onSuggestionSelect: (String) -> Unit,
+ onTabSelect: (SearchTabType) -> Unit,
+ modifier: Modifier = Modifier,
+ onResultClick: (Application) -> Unit = {},
+ onPrimaryActionClick: (Application) -> Unit = {},
+ onShowMoreClick: (Application) -> Unit = {},
+ onPrivacyClick: (Application) -> Unit = {},
+) {
+ val focusManager = LocalFocusManager.current
+ val keyboardController = LocalSoftwareKeyboardController.current
+ val lifecycleOwner = LocalLifecycleOwner.current
+ val focusRequester = remember { FocusRequester() }
+ val shouldAutoFocus = !uiState.hasSubmittedSearch
+ var isSearchExpanded by rememberSaveable { mutableStateOf(shouldAutoFocus) }
+ var hasRequestedInitialFocus by rememberSaveable { mutableStateOf(false) }
+ val selectedTab = uiState.selectedTab
+ val showSuggestions = isSearchExpanded && uiState.isSuggestionVisible
+ val showResults =
+ uiState.hasSubmittedSearch && selectedTab != null && uiState.availableTabs.isNotEmpty()
+
+ LaunchedEffect(lifecycleOwner, shouldAutoFocus) {
+ lifecycleOwner.repeatOnLifecycle(Lifecycle.State.RESUMED) {
+ if (shouldAutoFocus && !hasRequestedInitialFocus) {
+ hasRequestedInitialFocus = true
+ withFrameNanos {
+ focusRequester.requestFocus()
+ keyboardController?.show()
+ }
+ } else {
+ // Intentionally no-op; the initial focus request has already happened.
+ }
+ }
+ }
+
+ LaunchedEffect(uiState.hasSubmittedSearch) {
+ if (uiState.hasSubmittedSearch) {
+ isSearchExpanded = false
+ focusManager.clearFocus()
+ } else {
+ // Intentionally no-op; results are not active so focus remains unchanged.
+ }
+ }
+
+ Scaffold(
+ modifier = modifier,
+ topBar = {
+ SearchTopBar(
+ uiState = uiState,
+ expanded = isSearchExpanded,
+ showSuggestions = showSuggestions,
+ focusRequester = focusRequester,
+ focusManager = focusManager,
+ onQueryChange = onQueryChange,
+ onClearQuery = onClearQuery,
+ onSearchSubmit = onSubmitSearch,
+ onSuggestionSelect = onSuggestionSelect,
+ onExpandedChange = { expanded ->
+ isSearchExpanded = expanded
+ if (expanded) {
+ focusRequester.requestFocus()
+ } else {
+ focusManager.clearFocus()
+ }
+ },
+ onBack = onBackClick,
+ )
+ },
+ ) { innerPadding ->
+ Column(
+ modifier = Modifier
+ .fillMaxSize()
+ .padding(innerPadding)
+ ) {
+ when {
+ showResults && selectedTab != null -> {
+ SearchResultsContent(
+ tabs = uiState.availableTabs,
+ selectedTab = selectedTab,
+ resultsByTab = uiState.resultsByTab,
+ onTabSelect = onTabSelect,
+ modifier = Modifier.fillMaxSize(),
+ onResultClick = onResultClick,
+ onPrimaryActionClick = onPrimaryActionClick,
+ onShowMoreClick = onShowMoreClick, onPrivacyClick = onPrivacyClick,
+ )
+ }
+
+ else -> {
+ // Suggestions render in the top bar dropdown; leave body empty.
+ }
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/foundation/e/apps/ui/compose/screens/SearchTopBar.kt b/app/src/main/java/foundation/e/apps/ui/compose/screens/SearchTopBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..458de70f5f0e2a73a1542f35aa58ec1a84864ebb
--- /dev/null
+++ b/app/src/main/java/foundation/e/apps/ui/compose/screens/SearchTopBar.kt
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.compose.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SearchBar
+import androidx.compose.material3.SearchBarDefaults
+import androidx.compose.material3.Text
+import androidx.compose.material3.surfaceColorAtElevation
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusManager
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import foundation.e.apps.R
+import foundation.e.apps.ui.compose.theme.AppTheme
+import foundation.e.apps.ui.search.v2.SearchTabType
+import foundation.e.apps.ui.search.v2.SearchUiState
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun SearchTopBar(
+ uiState: SearchUiState,
+ expanded: Boolean,
+ showSuggestions: Boolean,
+ focusRequester: FocusRequester,
+ focusManager: FocusManager,
+ onQueryChange: (String) -> Unit,
+ onClearQuery: () -> Unit,
+ onSearchSubmit: (String) -> Unit,
+ onSuggestionSelect: (String) -> Unit,
+ onExpandedChange: (Boolean) -> Unit,
+ onBack: () -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ SearchBar(
+ modifier = modifier
+ .fillMaxWidth()
+ .testTag(SearchTopBarTestTags.SEARCH_BAR),
+ colors = SearchBarDefaults.colors(
+ containerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(3.dp),
+ dividerColor = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f),
+ ),
+ expanded = expanded,
+ onExpandedChange = { isExpanded ->
+ onExpandedChange(isExpanded)
+ },
+ inputField = {
+ SearchBarDefaults.InputField(
+ modifier = Modifier
+ .fillMaxWidth()
+ .focusRequester(focusRequester)
+ .testTag(SearchTopBarTestTags.INPUT_FIELD),
+ query = uiState.query,
+ onQueryChange = { query ->
+ onExpandedChange(true)
+ onQueryChange(query)
+ },
+ onSearch = { query ->
+ onExpandedChange(false)
+ focusManager.clearFocus()
+ onSearchSubmit(query)
+ },
+ expanded = expanded,
+ onExpandedChange = { isExpanded ->
+ onExpandedChange(isExpanded)
+ },
+ placeholder = { Text(text = stringResource(id = R.string.search_hint)) },
+ leadingIcon = {
+ IconButton(
+ modifier = Modifier.testTag(SearchTopBarTestTags.BACK_BUTTON),
+ onClick = {
+ focusManager.clearFocus()
+ onBack()
+ },
+ ) {
+ Icon(
+ imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+ contentDescription = stringResource(id = R.string.search_back_button),
+ )
+ }
+ },
+ trailingIcon = {
+ if (uiState.query.isNotEmpty()) {
+ IconButton(
+ modifier = Modifier.testTag(SearchTopBarTestTags.CLEAR_BUTTON),
+ onClick = {
+ onClearQuery()
+ onExpandedChange(true)
+ focusRequester.requestFocus()
+ },
+ ) {
+ Icon(
+ imageVector = Icons.Filled.Close,
+ contentDescription = stringResource(id = R.string.search_clear_button),
+ )
+ }
+ }
+ },
+ )
+ },
+ ) {
+ if (showSuggestions) {
+ SuggestionList(
+ suggestions = uiState.suggestions,
+ onSuggestionSelect = { suggestion ->
+ onExpandedChange(false)
+ focusManager.clearFocus()
+ onSuggestionSelect(suggestion)
+ },
+ modifier = Modifier
+ .fillMaxWidth()
+ .background(MaterialTheme.colorScheme.surfaceColorAtElevation(3.dp)),
+ )
+ }
+ }
+}
+
+@Composable
+private fun SuggestionList(
+ suggestions: List,
+ onSuggestionSelect: (String) -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ LazyColumn(
+ modifier = modifier.testTag(SearchTopBarTestTags.SUGGESTIONS_LIST),
+ ) {
+ itemsIndexed(
+ items = suggestions,
+ key = { _, suggestion -> suggestion },
+ ) { index, suggestion ->
+ ListItem(
+ modifier = Modifier
+ .fillMaxWidth()
+ .clickable { onSuggestionSelect(suggestion) }
+ .testTag("${SearchTopBarTestTags.SUGGESTION_ITEM_PREFIX}$index"),
+ headlineContent = { Text(text = suggestion) },
+ leadingContent = {
+ Icon(
+ imageVector = Icons.Filled.Search,
+ contentDescription = stringResource(id = R.string.menu_search),
+ tint = MaterialTheme.colorScheme.onSurfaceVariant,
+ )
+ },
+ )
+ }
+ }
+}
+
+internal object SearchTopBarTestTags {
+ const val SEARCH_BAR = "search_top_bar"
+ const val INPUT_FIELD = "search_top_bar_input_field"
+ const val BACK_BUTTON = "search_top_bar_back_button"
+ const val CLEAR_BUTTON = "search_top_bar_clear_button"
+ const val SUGGESTIONS_LIST = "search_top_bar_suggestions_list"
+ const val SUGGESTION_ITEM_PREFIX = "search_top_bar_suggestion_"
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun SearchTopBarPreview() {
+ AppTheme(darkTheme = true) {
+ val focusRequester = remember { FocusRequester() }
+ val focusManager = LocalFocusManager.current
+ var expanded by remember { mutableStateOf(true) }
+ val sampleState = SearchUiState(
+ query = "browser",
+ suggestions = listOf(
+ "browser",
+ "browser apps",
+ "browser downloader",
+ "browser for android",
+ ),
+ isSuggestionVisible = true,
+ availableTabs = listOf(
+ SearchTabType.COMMON_APPS,
+ SearchTabType.OPEN_SOURCE,
+ SearchTabType.PWA,
+ ),
+ selectedTab = SearchTabType.OPEN_SOURCE,
+ hasSubmittedSearch = false,
+ )
+
+ SearchTopBar(
+ uiState = sampleState,
+ expanded = expanded,
+ showSuggestions = expanded && sampleState.suggestions.isNotEmpty(),
+ focusRequester = focusRequester,
+ focusManager = focusManager,
+ onQueryChange = { expanded = true },
+ onClearQuery = { expanded = true },
+ onSearchSubmit = { expanded = false },
+ onSuggestionSelect = { expanded = false },
+ onExpandedChange = { expanded = it },
+ onBack = {},
+ )
+ }
+}
diff --git a/app/src/main/java/foundation/e/apps/ui/search/v2/SearchFragmentV2.kt b/app/src/main/java/foundation/e/apps/ui/search/v2/SearchFragmentV2.kt
index c78d7ff04aa799952eae67b77274f81c91e85741..f86edb917148d92deaa5dddbd066bc12eae77c02 100644
--- a/app/src/main/java/foundation/e/apps/ui/search/v2/SearchFragmentV2.kt
+++ b/app/src/main/java/foundation/e/apps/ui/search/v2/SearchFragmentV2.kt
@@ -20,19 +20,38 @@ package foundation.e.apps.ui.search.v2
import android.os.Bundle
import android.view.View
+import androidx.compose.runtime.getValue
import androidx.compose.ui.platform.ComposeView
import androidx.compose.ui.platform.ViewCompositionStrategy
import androidx.fragment.app.Fragment
+import androidx.fragment.app.viewModels
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import dagger.hilt.android.AndroidEntryPoint
import foundation.e.apps.R
+import foundation.e.apps.ui.compose.screens.SearchScreen
import foundation.e.apps.ui.compose.theme.AppTheme
+@AndroidEntryPoint
class SearchFragmentV2 : Fragment(R.layout.fragment_search_v2) {
+ private val searchViewModel: SearchViewModelV2 by viewModels()
+
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
val composeView = view.findViewById(R.id.composeView)
composeView.setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
composeView.setContent {
- AppTheme { }
+ AppTheme {
+ val uiState by searchViewModel.uiState.collectAsStateWithLifecycle()
+ SearchScreen(
+ uiState = uiState,
+ onQueryChange = searchViewModel::onQueryChanged,
+ onBackClick = { requireActivity().onBackPressedDispatcher.onBackPressed() },
+ onClearQuery = searchViewModel::onQueryCleared,
+ onSubmitSearch = searchViewModel::onSearchSubmitted,
+ onSuggestionSelect = searchViewModel::onSuggestionSelected,
+ onTabSelect = searchViewModel::onTabSelected,
+ )
+ }
}
}
}
diff --git a/app/src/main/java/foundation/e/apps/ui/search/v2/SearchViewModelV2.kt b/app/src/main/java/foundation/e/apps/ui/search/v2/SearchViewModelV2.kt
index 3c178adec62aeb6f3c01d8b487a73044cb447d12..186f47aaebfd5b057ddb8a8463eae616aeaa0587 100644
--- a/app/src/main/java/foundation/e/apps/ui/search/v2/SearchViewModelV2.kt
+++ b/app/src/main/java/foundation/e/apps/ui/search/v2/SearchViewModelV2.kt
@@ -19,8 +19,283 @@
package foundation.e.apps.ui.search.v2
import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
+import foundation.e.apps.data.Stores
+import foundation.e.apps.data.application.data.Application
+import foundation.e.apps.data.application.data.Ratings
+import foundation.e.apps.data.enums.Source
+import foundation.e.apps.data.enums.Source.OPEN_SOURCE
+import foundation.e.apps.data.enums.Source.PLAY_STORE
+import foundation.e.apps.data.enums.Source.PWA
+import foundation.e.apps.data.enums.Status
+import foundation.e.apps.data.preference.AppLoungePreference
+import foundation.e.apps.data.search.SuggestionSource
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
import javax.inject.Inject
+private const val SUGGESTION_DEBOUNCE_MS = 500L
+private const val FAKE_RESULTS_PER_TAB = 50
+
+enum class SearchTabType {
+ COMMON_APPS,
+ OPEN_SOURCE,
+ PWA,
+}
+
+data class SearchUiState(
+ val query: String = "",
+ val suggestions: List = emptyList(),
+ val isSuggestionVisible: Boolean = false,
+ val availableTabs: List = emptyList(),
+ val selectedTab: SearchTabType? = null,
+ val resultsByTab: Map> = emptyMap(),
+ val hasSubmittedSearch: Boolean = false,
+)
+
@HiltViewModel
-class SearchViewModelV2 @Inject constructor() : ViewModel()
+class SearchViewModelV2 @Inject constructor(
+ private val suggestionSource: SuggestionSource,
+ private val appLoungePreference: AppLoungePreference,
+ private val stores: Stores
+) : ViewModel() {
+
+ private val initialVisibleTabs = resolveVisibleTabs()
+
+ private val _uiState = MutableStateFlow(
+ SearchUiState(
+ availableTabs = initialVisibleTabs,
+ selectedTab = initialVisibleTabs.firstOrNull(),
+ )
+ )
+ val uiState: StateFlow = _uiState.asStateFlow()
+
+ private var suggestionJob: Job? = null
+
+ init {
+ viewModelScope.launch {
+ stores.enabledStoresFlow
+ .collect { handleStoreSelectionChanged() }
+ }
+ }
+
+ fun onQueryChanged(newQuery: String) {
+ _uiState.update { current ->
+ current.copy(query = newQuery)
+ }
+
+ suggestionJob?.cancel()
+ if (newQuery.isBlank()) {
+ _uiState.update { current ->
+ if (current.hasSubmittedSearch && current.availableTabs.isNotEmpty()) {
+ // Keep existing results/tabs visible; just hide suggestions and clear query.
+ current.copy(
+ suggestions = emptyList(),
+ isSuggestionVisible = false,
+ query = "",
+ )
+ } else {
+ val visibleTabs = resolveVisibleTabs()
+ current.copy(
+ suggestions = emptyList(),
+ isSuggestionVisible = false,
+ hasSubmittedSearch = false,
+ resultsByTab = emptyMap(),
+ availableTabs = visibleTabs,
+ selectedTab = visibleTabs.firstOrNull(),
+ query = "",
+ )
+ }
+ }
+ return
+ }
+
+ if (!appLoungePreference.isPlayStoreSelected()) {
+ _uiState.update { current ->
+ current.copy(
+ suggestions = emptyList(),
+ isSuggestionVisible = false,
+ )
+ }
+ return
+ }
+
+ suggestionJob = viewModelScope.launch {
+ delay(SUGGESTION_DEBOUNCE_MS)
+ val suggestions = suggestionSource.suggest(newQuery)
+ _uiState.update { current ->
+ current.copy(
+ suggestions = suggestions,
+ isSuggestionVisible = suggestions.isNotEmpty(),
+ )
+ }
+ }
+ }
+
+ fun onSuggestionSelected(suggestion: String) {
+ onSearchSubmitted(suggestion)
+ }
+
+ fun onQueryCleared() {
+ suggestionJob?.cancel()
+ _uiState.update { current ->
+ if (current.hasSubmittedSearch && current.availableTabs.isNotEmpty()) {
+ current.copy(
+ query = "",
+ suggestions = emptyList(),
+ isSuggestionVisible = false,
+ )
+ } else {
+ val visibleTabs = resolveVisibleTabs()
+ current.copy(
+ query = "",
+ suggestions = emptyList(),
+ isSuggestionVisible = false,
+ hasSubmittedSearch = false,
+ resultsByTab = emptyMap(),
+ availableTabs = visibleTabs,
+ selectedTab = visibleTabs.firstOrNull(),
+ )
+ }
+ }
+ }
+
+ fun onSearchSubmitted(submitted: String) {
+ val trimmedQuery = submitted.trim()
+ if (trimmedQuery.isEmpty()) {
+ onQueryCleared()
+ return
+ }
+
+ val visibleTabs = resolveVisibleTabs()
+
+ val selectedTab = _uiState.value.selectedTab?.takeIf { visibleTabs.contains(it) }
+ ?: visibleTabs.firstOrNull()
+
+ val results = if (visibleTabs.isEmpty()) {
+ emptyMap()
+ } else {
+ buildResultsForTabs(trimmedQuery, visibleTabs, emptyMap())
+ }
+
+ _uiState.update { current ->
+ current.copy(
+ query = trimmedQuery,
+ suggestions = emptyList(),
+ isSuggestionVisible = false,
+ availableTabs = visibleTabs,
+ selectedTab = selectedTab,
+ resultsByTab = results,
+ hasSubmittedSearch = visibleTabs.isNotEmpty(),
+ )
+ }
+ }
+
+ fun onTabSelected(tab: SearchTabType) {
+ _uiState.update { current ->
+ if (!current.availableTabs.contains(tab)) {
+ current
+ } else {
+ current.copy(selectedTab = tab)
+ }
+ }
+ }
+
+ private fun handleStoreSelectionChanged() {
+ val visibleTabs = resolveVisibleTabs()
+
+ _uiState.update { current ->
+ val selectedTab = current.selectedTab?.takeIf { visibleTabs.contains(it) }
+ ?: visibleTabs.firstOrNull()
+
+ val updatedResults = if (current.hasSubmittedSearch && visibleTabs.isNotEmpty()) {
+ buildResultsForTabs(
+ query = current.query,
+ visibleTabs = visibleTabs,
+ existing = current.resultsByTab,
+ )
+ } else {
+ emptyMap()
+ }
+
+ current.copy(
+ availableTabs = visibleTabs,
+ selectedTab = selectedTab,
+ resultsByTab = updatedResults,
+ hasSubmittedSearch = current.hasSubmittedSearch && visibleTabs.isNotEmpty(),
+ isSuggestionVisible = current.isSuggestionVisible && appLoungePreference.isPlayStoreSelected(),
+ )
+ }
+ }
+
+ private fun resolveVisibleTabs(): List =
+ stores.getStores().mapNotNull { (key, _) ->
+ when (key) {
+ PLAY_STORE -> SearchTabType.COMMON_APPS
+ OPEN_SOURCE -> SearchTabType.OPEN_SOURCE
+ PWA -> SearchTabType.PWA
+ else -> null
+ }
+ }
+
+ private fun buildResultsForTabs(
+ query: String,
+ visibleTabs: List,
+ existing: Map>,
+ ): Map> {
+ if (query.isBlank()) return emptyMap()
+
+ return buildMap {
+ visibleTabs.forEach { tab ->
+ val preserved = existing[tab]
+ put(tab, preserved ?: generateFakeResultsFor(tab, query))
+ }
+ }
+ }
+
+ private fun generateFakeResultsFor(tab: SearchTabType, query: String): List {
+ val displayQuery = query.ifBlank { "Result" }
+ val source = when (tab) {
+ SearchTabType.COMMON_APPS -> Source.PLAY_STORE
+ SearchTabType.OPEN_SOURCE -> Source.OPEN_SOURCE
+ SearchTabType.PWA -> Source.PWA
+ }
+
+ return (1..FAKE_RESULTS_PER_TAB).map { index ->
+ val packageName = when (tab) {
+ SearchTabType.COMMON_APPS -> "com.example.standard.$index"
+ SearchTabType.OPEN_SOURCE -> "org.example.foss.$index"
+ SearchTabType.PWA -> "org.example.pwa.$index"
+ }
+
+ Application(
+ _id = "$tab-$index",
+ name = "${tab.toReadable()} $index for $displayQuery",
+ author = "Author $index",
+ package_name = packageName,
+ source = source,
+ ratings = Ratings(usageQualityScore = 4.0 + (index % 3) * 0.1),
+ is_pwa = tab == SearchTabType.PWA,
+ status = when (index % 4) {
+ 0 -> Status.UNAVAILABLE
+ 1 -> Status.UPDATABLE
+ 2 -> Status.INSTALLED
+ else -> Status.DOWNLOADING
+ },
+ price = if (index % 5 == 0) "$1.$index" else "",
+ )
+ }
+ }
+
+ private fun SearchTabType.toReadable(): String = when (this) {
+ SearchTabType.COMMON_APPS -> "Standard app"
+ SearchTabType.OPEN_SOURCE -> "Open source app"
+ SearchTabType.PWA -> "Web app"
+ }
+}
diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml
index 1f2a0cfb1687f5a0457ee414a211dee85a0b8226..73457fec9d2a9bc98c7ebee287ebc83d69deede0 100644
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -95,6 +95,8 @@
Keine Verbindung möglich. Bitte überprüfe die Internetverbindung und versuche es erneut
Start
App-Suche
+ Zurück
+ Suche löschen
Wir empfehlen, ein spezielles Google-Konto für die App Lounge zu erstellen und sich anschließend damit anzumelden. Dies bietet die beste Balance zwischen Datenschutz und Komfort. Alternativ kannst du den anonymen Modus verwenden.
Überprüfungsintervall für Aktualisierungen
Das Herunterladen und Installieren von App-Aktualisierungen im Hintergrund ausführen
diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml
index f08004c8480be4576bf153d2e8d132932b4db80e..1cb811082278ab9e7c6bbdf0990552a94241761b 100644
--- a/app/src/main/res/values-es/strings.xml
+++ b/app/src/main/res/values-es/strings.xml
@@ -34,6 +34,8 @@
Actualizaciones
Ajustes
Buscar una aplicación
+ Atrás
+ Borrar búsqueda
No se encontraron aplicaciones…
Juegos
Código abierto
diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml
index ba7889139227171d820f71c4c6d0710889b2062c..a7a99e44d4693bf7e3da0a2176dee53da9ef4cdb 100644
--- a/app/src/main/res/values-fi/strings.xml
+++ b/app/src/main/res/values-fi/strings.xml
@@ -83,6 +83,8 @@
Sovellukset
Sovelluksia ei löytynyt…
Hae sovellusta
+ Takaisin
+ Tyhjennä haku
Asetukset
Päivitykset
Hae
diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml
index 30c6e7405b909b9f3f4d17e0756876a8d1ab6444..bc5f01263f8baca665cc51af6007f7e5f3b01656 100644
--- a/app/src/main/res/values-fr/strings.xml
+++ b/app/src/main/res/values-fr/strings.xml
@@ -52,6 +52,8 @@
Mises à jour
Paramètres
Rechercher une application
+ Retour
+ Effacer la recherche
Applications
Jeux
Open Source
diff --git a/app/src/main/res/values-is/strings.xml b/app/src/main/res/values-is/strings.xml
index 2d05cc99d2c8ca9f92eafe421f2685f48f4270bb..5e6902d1f8b6cbf6644c21f8b8f1d2ffb9cfe99e 100644
--- a/app/src/main/res/values-is/strings.xml
+++ b/app/src/main/res/values-is/strings.xml
@@ -25,6 +25,8 @@
Uppfærslur
Stillingar
Leita að forriti
+ Til baka
+ Hreinsa leit
Engin forrit fundust…
Forrit
Leikir
diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml
index 19df4d2493ec523a54e4b85b40aca7d1cc794096..d1e0c320d4a73bacabe2ede24e3d0a526e7f5a29 100644
--- a/app/src/main/res/values-it/strings.xml
+++ b/app/src/main/res/values-it/strings.xml
@@ -29,6 +29,8 @@
Aggiornamenti
Impostazioni
Cerca una App
+ Indietro
+ Cancella ricerca
Non ho trovato App…
App
Giochi
diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml
index 91e082cd17d0e4a88bd20d3f44072ea48efec620..deee7ecfd96baca0cfc25d91e81b2fb091cfe1f3 100644
--- a/app/src/main/res/values-ja/strings.xml
+++ b/app/src/main/res/values-ja/strings.xml
@@ -6,6 +6,8 @@
検索
設定
アプリを検索
+ 戻る
+ 検索をクリア
アプリが見つかりませんでした…
アプリケーション
ゲーム
diff --git a/app/src/main/res/values-nb-rNO/strings.xml b/app/src/main/res/values-nb-rNO/strings.xml
index 062395d978bc1b677fddfa55fb4ce6833df10fbc..235591a0f8c5213760060604c719ee74a6482be4 100644
--- a/app/src/main/res/values-nb-rNO/strings.xml
+++ b/app/src/main/res/values-nb-rNO/strings.xml
@@ -96,6 +96,8 @@
Vennligst velg minst én applikasjonskilde.
Logg ut
Søk etter en applikasjon
+ Tilbake
+ Tøm søk
Innstillinger
Oppdateringer
Søk
diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml
index 3eeb2fbd190d3d8c09cdf95547fb0abc62747a60..813255c9cc933f9911f22ed25425ff4052329a82 100644
--- a/app/src/main/res/values-nl/strings.xml
+++ b/app/src/main/res/values-nl/strings.xml
@@ -123,6 +123,8 @@
Toepassingen
Geen apps gevonden…
App zoeken
+ Terug
+ Zoekopdracht wissen
Instellingen
Updates
Zoeken
diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml
index 1dd3736622f743c961ca02721bf1f895397a4806..b5a9b9372f80453fd2f82f31dd9a156a93b80636 100644
--- a/app/src/main/res/values-pt-rBR/strings.xml
+++ b/app/src/main/res/values-pt-rBR/strings.xml
@@ -7,6 +7,8 @@
Atualizações
Configurações
Pesquise um aplicativo
+ Voltar
+ Limpar pesquisa
Nenhum aplicativo encontrado…
Aplicativos
Jogos
diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml
index 103bd98b6088863df79bc654fc6233ff08de1bad..c1f51152df693cd938e9f6a5ab1924316816a78c 100644
--- a/app/src/main/res/values-ru/strings.xml
+++ b/app/src/main/res/values-ru/strings.xml
@@ -54,6 +54,8 @@
Приложения
Приложения не найдены…
Поиск приложения
+ Назад
+ Очистить поиск
Настройки
Обновления
Поиск
diff --git a/app/src/main/res/values-sk/strings.xml b/app/src/main/res/values-sk/strings.xml
index e35629801ef5ebc49b3c744519401342f148b342..60432be8b153aed729e643efd1562fdd4ba12eaa 100644
--- a/app/src/main/res/values-sk/strings.xml
+++ b/app/src/main/res/values-sk/strings.xml
@@ -37,6 +37,8 @@
Aplikácie
Nenašli sa žiadne aplikácie…
Vyhľadajte aplikáciu
+ Späť
+ Vymazať vyhľadávanie
Nastavenia
Aktualizácie
Hľadať
diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml
index 7a7a5ee2868a363eb7b019499535b9fbd487686b..a85f2669322d48962d83bb785a0945e476c3e029 100644
--- a/app/src/main/res/values-sv/strings.xml
+++ b/app/src/main/res/values-sv/strings.xml
@@ -21,6 +21,8 @@
Uppdateringar
Inställningar
Sök efter en app
+ Tillbaka
+ Rensa sökning
Inga appar hittades …
Appar
Spel
diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml
index fc37cea29523cf660e53dbd1557ebbee7ef8ec0a..2baf2b1b80d5523776f74ed6ea6f0c11eed5ad88 100644
--- a/app/src/main/res/values-tr/strings.xml
+++ b/app/src/main/res/values-tr/strings.xml
@@ -101,6 +101,8 @@
Ana Menü
Ayarlar
Bir uygulama arayın
+ Geri
+ Aramayı temizle
Uygulama bulunamadı…
Oyunlar
Kullanılabilir güncellemeleri göster
diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml
index 8e6a747632fcf39b73dc7b0de7c30348a20fe98f..278190640cfc7896e69303394ffc58964f945708 100644
--- a/app/src/main/res/values-uk/strings.xml
+++ b/app/src/main/res/values-uk/strings.xml
@@ -54,6 +54,8 @@
Ігри
Нічого не знайдено…
Шукати застосунки
+ Назад
+ Очистити пошук
Налаштування
Категорії
Домівка
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 3dca374651171f86c247d1f54543f5084f1c45f2..667fe751d764a4de0b4b7fdc225c48c8fc979c96 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -26,8 +26,14 @@
Search
Updates
Settings
+
Search for an app
+ Back
+ Clear search
+ APPS
+ OPEN SOURCE
+ WEB APPS
No apps found…
diff --git a/app/src/test/java/foundation/e/apps/data/StoresTest.kt b/app/src/test/java/foundation/e/apps/data/StoresTest.kt
index 19ff1de845ec666f6d5a8006c75e89b5844b7809..46358314364cd88bfbe37620e4cc08c8e3c3f690 100644
--- a/app/src/test/java/foundation/e/apps/data/StoresTest.kt
+++ b/app/src/test/java/foundation/e/apps/data/StoresTest.kt
@@ -8,6 +8,7 @@ import foundation.e.apps.data.playstore.PlayStoreRepository
import foundation.e.apps.data.preference.AppLoungePreference
import io.mockk.every
import io.mockk.mockk
+import io.mockk.verify
import org.junit.Before
import org.junit.Test
@@ -16,19 +17,33 @@ class StoresTest {
private val playStoreRepository: PlayStoreRepository = mockk(relaxed = true)
private val cleanApkAppsRepository: CleanApkAppsRepository = mockk(relaxed = true)
private val cleanApkPwaRepository: CleanApkPwaRepository = mockk(relaxed = true)
- private val preference: AppLoungePreference = mockk()
+ private lateinit var preference: AppLoungePreference
private lateinit var stores: Stores
+ private var playStoreSelected = true
+ private var openSourceSelected = true
+ private var pwaSelected = false
@Before
fun setUp() {
- stores = Stores(playStoreRepository, cleanApkAppsRepository, cleanApkPwaRepository, preference)
+ preference = mockk(relaxed = true)
+ every { preference.isPlayStoreSelected() } answers { playStoreSelected }
+ every { preference.isOpenSourceSelected() } answers { openSourceSelected }
+ every { preference.isPWASelected() } answers { pwaSelected }
+ every { preference.enablePlayStore() } answers { playStoreSelected = true }
+ every { preference.disablePlayStore() } answers { playStoreSelected = false }
+ every { preference.enableOpenSource() } answers { openSourceSelected = true }
+ every { preference.disableOpenSource() } answers { openSourceSelected = false }
+ every { preference.enablePwa() } answers { pwaSelected = true }
+ every { preference.disablePwa() } answers { pwaSelected = false }
+
+ buildStores()
}
@Test
fun getStoresReturnsOnlyEnabledSources() {
- every { preference.isPlayStoreSelected() } returns true
- every { preference.isOpenSourceSelected() } returns false
- every { preference.isPWASelected() } returns true
+ playStoreSelected = true
+ openSourceSelected = false
+ pwaSelected = true
val result = stores.getStores()
@@ -39,21 +54,18 @@ class StoresTest {
@Test
fun enableAndDisableStoreProxiesPreference() {
- every { preference.enableOpenSource() } returns Unit
- every { preference.disableOpenSource() } returns Unit
-
stores.enableStore(Source.OPEN_SOURCE)
stores.disableStore(Source.OPEN_SOURCE)
- io.mockk.verify { preference.enableOpenSource() }
- io.mockk.verify { preference.disableOpenSource() }
+ verify { preference.enableOpenSource() }
+ verify { preference.disableOpenSource() }
}
@Test
fun isStoreEnabledReflectsPreferenceFlags() {
- every { preference.isPlayStoreSelected() } returns false
- every { preference.isOpenSourceSelected() } returns false
- every { preference.isPWASelected() } returns true
+ playStoreSelected = false
+ openSourceSelected = false
+ pwaSelected = true
val enabled = stores.isStoreEnabled(Source.PWA)
val disabled = stores.isStoreEnabled(Source.PLAY_STORE)
@@ -66,4 +78,40 @@ class StoresTest {
fun enableStoreThrowsForUnknownSource() {
stores.enableStore(Source.SYSTEM_APP)
}
+
+ @Test
+ fun enabledStoresFlowReflectsInitialSelection() {
+ playStoreSelected = true
+ openSourceSelected = false
+ pwaSelected = true
+ buildStores()
+
+ assertThat(stores.enabledStoresFlow.value)
+ .containsExactly(Source.PLAY_STORE, Source.PWA)
+ }
+
+ @Test
+ fun enabledStoresFlowUpdatesAfterToggleChanges() {
+ playStoreSelected = true
+ openSourceSelected = false
+ pwaSelected = false
+ buildStores()
+
+ stores.enableStore(Source.OPEN_SOURCE)
+ assertThat(stores.enabledStoresFlow.value)
+ .containsExactly(Source.PLAY_STORE, Source.OPEN_SOURCE)
+
+ stores.disableStore(Source.PLAY_STORE)
+ assertThat(stores.enabledStoresFlow.value)
+ .containsExactly(Source.OPEN_SOURCE)
+ }
+
+ private fun buildStores() {
+ stores = Stores(
+ playStoreRepository,
+ cleanApkAppsRepository,
+ cleanApkPwaRepository,
+ preference,
+ )
+ }
}
diff --git a/app/src/test/java/foundation/e/apps/data/playstore/search/PlayStoreSuggestionSourceTest.kt b/app/src/test/java/foundation/e/apps/data/playstore/search/PlayStoreSuggestionSourceTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..383f446e4d17d58ed3991e54109761ec0e64bda0
--- /dev/null
+++ b/app/src/test/java/foundation/e/apps/data/playstore/search/PlayStoreSuggestionSourceTest.kt
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.data.playstore.search
+
+import com.google.common.truth.Truth.assertThat
+import foundation.e.apps.data.application.search.SearchSuggestion
+import foundation.e.apps.data.enums.Source
+import foundation.e.apps.data.playstore.PlayStoreSearchHelper
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.junit.Before
+import org.junit.Test
+
+class PlayStoreSuggestionSourceTest {
+
+ private val helper: PlayStoreSearchHelper = mockk()
+ private lateinit var source: PlayStoreSuggestionSource
+
+ @Before
+ fun setUp() {
+ source = PlayStoreSuggestionSource(helper)
+ }
+
+ @Test
+ fun `blank query returns empty list without calling helper`() = runTest {
+ val result = source.suggest(" ")
+
+ assertThat(result).isEmpty()
+ coVerify(exactly = 0) { helper.getSearchSuggestions(any()) }
+ }
+
+ @Test
+ fun `non-blank query trims before calling helper and normalizes suggestions`() = runTest {
+ coEvery { helper.getSearchSuggestions("signal") } returns suggestionsOf(
+ " Signal ",
+ " ",
+ "",
+ "Firefox"
+ )
+
+ val result = source.suggest(" signal ")
+
+ assertThat(result).containsExactly("Signal", "Firefox").inOrder()
+ coVerify(exactly = 1) { helper.getSearchSuggestions("signal") }
+ }
+
+ @Test
+ fun `case-insensitive duplicates keep the first occurrence`() = runTest {
+ coEvery { helper.getSearchSuggestions("vlc") } returns suggestionsOf(
+ " VLC ",
+ "vlc",
+ "Vlc",
+ "Firefox"
+ )
+
+ val result = source.suggest("vlc")
+
+ assertThat(result).containsExactly("VLC", "Firefox").inOrder()
+ }
+
+ @Test
+ fun `results are capped to ten suggestions`() = runTest {
+ val titles = (1..12).map { index -> "App $index" }
+ coEvery { helper.getSearchSuggestions("apps") } returns suggestionsOf(*titles.toTypedArray())
+
+ val result = source.suggest("apps")
+
+ assertThat(result).containsExactlyElementsIn(titles.take(10)).inOrder()
+ }
+
+ @Test
+ fun `helper failure returns empty list`() = runTest {
+ coEvery { helper.getSearchSuggestions("boom") } throws IllegalStateException("boom")
+
+ val result = source.suggest("boom")
+
+ assertThat(result).isEmpty()
+ coVerify(exactly = 1) { helper.getSearchSuggestions("boom") }
+ }
+
+ private fun suggestionsOf(vararg titles: String): List {
+ return titles.map { title -> SearchSuggestion(title, Source.PLAY_STORE) }
+ }
+}
diff --git a/app/src/test/java/foundation/e/apps/data/search/FakeSuggestionSource.kt b/app/src/test/java/foundation/e/apps/data/search/FakeSuggestionSource.kt
new file mode 100644
index 0000000000000000000000000000000000000000..911ce37014fdc87d25c18bb251e2def6a88a60b5
--- /dev/null
+++ b/app/src/test/java/foundation/e/apps/data/search/FakeSuggestionSource.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.data.search
+
+/*
+ * Copyright (C) 2025 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+class FakeSuggestionSource(
+ private val canned: List = listOf(
+ "Telegram",
+ "Telegram FOSS",
+ "Telegram X",
+ "Fennec",
+ "Firefox",
+ "Signal",
+ "NewPipe",
+ "VLC",
+ ),
+) : SuggestionSource {
+
+ override suspend fun suggest(query: String): List {
+ val lowered = query.trim().lowercase()
+ if (lowered.isEmpty()) return emptyList()
+ return canned.filter { item -> item.lowercase().contains(lowered) }
+ .take(10)
+ }
+}
diff --git a/app/src/test/java/foundation/e/apps/ui/search/v2/SearchViewModelV2Test.kt b/app/src/test/java/foundation/e/apps/ui/search/v2/SearchViewModelV2Test.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7a95ccc03f2d8a96a4eeaa3533b4fbe64eaabb88
--- /dev/null
+++ b/app/src/test/java/foundation/e/apps/ui/search/v2/SearchViewModelV2Test.kt
@@ -0,0 +1,335 @@
+/*
+ * Copyright (C) 2026 e Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+package foundation.e.apps.ui.search.v2
+
+import foundation.e.apps.data.Stores
+import foundation.e.apps.data.cleanapk.repositories.CleanApkAppsRepository
+import foundation.e.apps.data.cleanapk.repositories.CleanApkPwaRepository
+import foundation.e.apps.data.enums.Source
+import foundation.e.apps.data.playstore.PlayStoreRepository
+import foundation.e.apps.data.preference.AppLoungePreference
+import foundation.e.apps.data.search.FakeSuggestionSource
+import foundation.e.apps.util.MainCoroutineRule
+import io.mockk.every
+import io.mockk.mockk
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+private const val DEBOUNCE_MS = 500L
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SearchViewModelV2Test {
+
+ @get:Rule
+ val mainCoroutineRule = MainCoroutineRule()
+
+ private lateinit var suggestionSource: FakeSuggestionSource
+ private lateinit var preference: AppLoungePreference
+ private lateinit var stores: Stores
+ private var playStoreSelected = true
+ private var openSourceSelected = true
+ private var pwaSelected = false
+ private lateinit var viewModel: SearchViewModelV2
+
+ @Before
+ fun setUp() {
+ suggestionSource = FakeSuggestionSource()
+ preference = mockk(relaxed = true)
+
+ every { preference.isPlayStoreSelected() } answers { playStoreSelected }
+ every { preference.isOpenSourceSelected() } answers { openSourceSelected }
+ every { preference.isPWASelected() } answers { pwaSelected }
+ every { preference.enablePlayStore() } answers { playStoreSelected = true }
+ every { preference.disablePlayStore() } answers { playStoreSelected = false }
+ every { preference.enableOpenSource() } answers { openSourceSelected = true }
+ every { preference.disableOpenSource() } answers { openSourceSelected = false }
+ every { preference.enablePwa() } answers { pwaSelected = true }
+ every { preference.disablePwa() } answers { pwaSelected = false }
+
+ buildViewModel()
+ }
+
+ private fun buildStores(): Stores {
+ val playStoreRepository = mockk(relaxed = true)
+ val cleanApkAppsRepository = mockk(relaxed = true)
+ val cleanApkPwaRepository = mockk(relaxed = true)
+
+ return Stores(
+ playStoreRepository,
+ cleanApkAppsRepository,
+ cleanApkPwaRepository,
+ preference
+ )
+ }
+
+ @Test
+ fun `play store disabled hides suggestions when typing`() = runTest {
+ playStoreSelected = false
+
+ viewModel.onQueryChanged("apps")
+ advanceDebounce()
+
+ val state = viewModel.uiState.value
+ assertTrue(state.suggestions.isEmpty())
+ assertFalse(state.isSuggestionVisible)
+ assertEquals("apps", state.query)
+ }
+
+ @Test
+ fun `matching query shows suggestions when play store enabled`() = runTest {
+ playStoreSelected = true
+
+ viewModel.onQueryChanged("tel")
+ advanceDebounce()
+
+ val state = viewModel.uiState.value
+ assertFalse(state.suggestions.isEmpty())
+ assertTrue(state.isSuggestionVisible)
+ assertEquals("tel", state.query)
+ }
+
+ @Test
+ fun `empty suggestions keep dropdown hidden`() = runTest {
+ playStoreSelected = true
+
+ viewModel.onQueryChanged("zzzz")
+ advanceDebounce()
+
+ val state = viewModel.uiState.value
+ assertTrue(state.suggestions.isEmpty())
+ assertFalse(state.isSuggestionVisible)
+ }
+
+ @Test
+ fun `blank query before submit clears tabs and results`() = runTest {
+ viewModel.onQueryChanged(" ")
+
+ val state = viewModel.uiState.value
+ assertTrue(state.resultsByTab.isEmpty())
+ assertEquals(visibleTabs(), state.availableTabs)
+ assertEquals(visibleTabs().firstOrNull(), state.selectedTab)
+ assertFalse(state.hasSubmittedSearch)
+ }
+
+ @Test
+ fun `blank query after submit hides suggestions but keeps results`() = runTest {
+ viewModel.onSearchSubmitted("query")
+ val resultsBefore = viewModel.uiState.value.resultsByTab
+ val tabsBefore = viewModel.uiState.value.availableTabs
+
+ viewModel.onQueryChanged(" ")
+
+ val state = viewModel.uiState.value
+ assertEquals(resultsBefore, state.resultsByTab)
+ assertEquals(tabsBefore, state.availableTabs)
+ assertTrue(state.hasSubmittedSearch)
+ assertFalse(state.isSuggestionVisible)
+ assertEquals("", state.query)
+ }
+
+ @Test
+ fun `clear query after submit retains tabs and results`() = runTest {
+ viewModel.onSearchSubmitted("query")
+ val resultsBefore = viewModel.uiState.value.resultsByTab
+ val tabsBefore = viewModel.uiState.value.availableTabs
+
+ viewModel.onQueryCleared()
+
+ val state = viewModel.uiState.value
+ assertEquals(resultsBefore, state.resultsByTab)
+ assertEquals(tabsBefore, state.availableTabs)
+ assertTrue(state.hasSubmittedSearch)
+ assertEquals("", state.query)
+ assertFalse(state.isSuggestionVisible)
+ }
+
+ @Test
+ fun `search submit trims query and builds per tab results`() = runTest {
+ playStoreSelected = true
+ openSourceSelected = true
+ pwaSelected = true
+ buildViewModel()
+
+ viewModel.onSearchSubmitted(" spaced query ")
+
+ val state = viewModel.uiState.value
+ assertEquals("spaced query", state.query)
+ assertEquals(visibleTabs(), state.availableTabs)
+ assertTrue(state.resultsByTab.keys.containsAll(visibleTabs()))
+ assertTrue(state.resultsByTab[SearchTabType.PWA]!!.all { it.name.contains("spaced query") })
+ assertTrue(state.resultsByTab.values.all { it.size == 50 })
+ assertTrue(state.hasSubmittedSearch)
+ assertTrue(state.suggestions.isEmpty())
+ assertFalse(state.isSuggestionVisible)
+ }
+
+ @Test
+ fun `search submit with no visible tabs yields no results`() = runTest {
+ playStoreSelected = false
+ openSourceSelected = false
+ pwaSelected = false
+ buildViewModel()
+
+ viewModel.onSearchSubmitted("anything")
+
+ viewModel.onQueryCleared()
+ val state = viewModel.uiState.value
+ assertTrue(state.availableTabs.isEmpty())
+ assertTrue(state.resultsByTab.isEmpty())
+ assertNull(state.selectedTab)
+ assertFalse(state.hasSubmittedSearch)
+ }
+
+ @Test
+ fun `search submit with blank query clears state`() = runTest {
+ playStoreSelected = true
+ buildViewModel()
+
+ viewModel.onSearchSubmitted(" ")
+
+ val state = viewModel.uiState.value
+ assertTrue(state.resultsByTab.isEmpty())
+ assertFalse(state.hasSubmittedSearch)
+ assertEquals(visibleTabs(), state.availableTabs)
+ assertEquals(visibleTabs().firstOrNull(), state.selectedTab)
+ assertEquals("", state.query)
+ }
+
+ @Test
+ fun `store change after submit rebuilds tabs and results`() = runTest {
+ playStoreSelected = true
+ openSourceSelected = false
+ pwaSelected = false
+ buildViewModel()
+ viewModel.onSearchSubmitted("apps")
+
+ stores.disableStore(Source.PLAY_STORE)
+ stores.enableStore(Source.OPEN_SOURCE)
+ runStoreUpdates()
+
+ val state = viewModel.uiState.value
+ assertEquals(listOf(SearchTabType.OPEN_SOURCE), state.availableTabs)
+ assertEquals(SearchTabType.OPEN_SOURCE, state.selectedTab)
+ assertTrue(state.resultsByTab.keys == setOf(SearchTabType.OPEN_SOURCE))
+ assertTrue(state.resultsByTab[SearchTabType.OPEN_SOURCE]!!.all { it.name.contains("apps") })
+ assertTrue(state.hasSubmittedSearch)
+ }
+
+ @Test
+ fun `store change hides suggestions when play store turns off`() = runTest {
+ playStoreSelected = true
+ buildViewModel()
+ viewModel.onQueryChanged("tel")
+ advanceDebounce()
+ assertTrue(viewModel.uiState.value.isSuggestionVisible)
+
+ stores.disableStore(Source.PLAY_STORE)
+ runStoreUpdates()
+
+ val state = viewModel.uiState.value
+ assertFalse(state.isSuggestionVisible)
+ }
+
+ @Test
+ fun `store change removing all tabs clears submitted state`() = runTest {
+ playStoreSelected = true
+ openSourceSelected = false
+ pwaSelected = false
+ buildViewModel()
+ viewModel.onSearchSubmitted("apps")
+
+ stores.disableStore(Source.PLAY_STORE)
+ runStoreUpdates()
+
+ val state = viewModel.uiState.value
+ assertTrue(state.availableTabs.isEmpty())
+ assertTrue(state.resultsByTab.isEmpty())
+ assertNull(state.selectedTab)
+ assertFalse(state.hasSubmittedSearch)
+ }
+
+ @Test
+ fun `tab selection ignores unavailable tabs`() = runTest {
+ playStoreSelected = true
+ openSourceSelected = true
+ pwaSelected = false
+ buildViewModel()
+
+ viewModel.onTabSelected(SearchTabType.PWA)
+ assertEquals(SearchTabType.COMMON_APPS, viewModel.uiState.value.selectedTab)
+
+ viewModel.onTabSelected(SearchTabType.OPEN_SOURCE)
+ assertEquals(SearchTabType.OPEN_SOURCE, viewModel.uiState.value.selectedTab)
+ }
+
+ @Test
+ fun `on suggestion selected delegates to search submission`() = runTest {
+ playStoreSelected = true
+ buildViewModel()
+
+ viewModel.onSuggestionSelected("Signal ")
+
+ val state = viewModel.uiState.value
+ assertEquals("Signal", state.query)
+ assertTrue(state.hasSubmittedSearch)
+ }
+
+ @Test
+ fun `store change before submit updates available tabs`() = runTest {
+ playStoreSelected = true
+ openSourceSelected = false
+ pwaSelected = false
+ buildViewModel()
+
+ stores.enableStore(Source.OPEN_SOURCE)
+ runStoreUpdates()
+
+ val state = viewModel.uiState.value
+ assertEquals(listOf(SearchTabType.COMMON_APPS, SearchTabType.OPEN_SOURCE), state.availableTabs)
+ assertEquals(SearchTabType.COMMON_APPS, state.selectedTab)
+ assertFalse(state.hasSubmittedSearch)
+ }
+
+ private fun advanceDebounce() {
+ mainCoroutineRule.testDispatcher.scheduler.advanceTimeBy(DEBOUNCE_MS)
+ mainCoroutineRule.testDispatcher.scheduler.runCurrent()
+ }
+
+ private fun runStoreUpdates() {
+ mainCoroutineRule.testDispatcher.scheduler.runCurrent()
+ }
+
+ private fun visibleTabs(): List = buildList {
+ if (playStoreSelected) add(SearchTabType.COMMON_APPS)
+ if (openSourceSelected) add(SearchTabType.OPEN_SOURCE)
+ if (pwaSelected) add(SearchTabType.PWA)
+ }
+
+ private fun buildViewModel() {
+ stores = buildStores()
+ viewModel = SearchViewModelV2(suggestionSource, preference, stores)
+ }
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 2b89cf589fb42c35e299e963c2afb0f039cf8bc3..4f431dd63006b4d720e564ddeba2b7e312ed11c3 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -5,6 +5,7 @@ androidGradlePlugin = "8.9.3"
appcompat = "1.7.0"
bcpgJdk15on = "1.60"
coil = "1.4.0"
+coilCompose = "1.4.0"
composeBom = "2025.12.01"
constraintlayout = "2.2.0"
core = "1.6.1"
@@ -64,6 +65,7 @@ activity-ktx = { module = "androidx.activity:activity-ktx", version.ref = "activ
appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat" }
bcpg-jdk15on = { module = "org.bouncycastle:bcpg-jdk15on", version.ref = "bcpgJdk15on" }
coil = { module = "io.coil-kt:coil", version.ref = "coil" }
+coil-compose = { module = "io.coil-kt:coil-compose", version.ref = "coilCompose" }
compose-bom = { module = "androidx.compose:compose-bom", version.ref = "composeBom" }
compose-material3 = { module = "androidx.compose.material3:material3" }
compose-material-icons-extended = { module = "androidx.compose.material:material-icons-extended" }