For #6087

- added engine hashmap so that we create each type of search provider once
(previously the providers to be added were checked by id, but since the id
is a UUID, it was always unique -> bug with multiple providers with same engine
but different id
- refactored update() flow so that it's more understandable + remove complex
method warning

app/src/main/java/org/mozilla/fenix/search/awesomebar/AwesomeBarView.kt

@@ -91,6 +91,7 @@ class AwesomeBarView(
     private val shortcutsEnginePickerProvider: ShortcutsSuggestionProvider
     private val bookmarksStorageSuggestionProvider: BookmarksStorageSuggestionProvider
     private val defaultSearchSuggestionProvider: SearchSuggestionProvider
+    private val searchSuggestionProviderMap: MutableMap<SearchEngine, SearchSuggestionProvider>
     private var providersInUse = mutableSetOf<AwesomeBar.SuggestionProvider>()
 
     private val loadUrlUseCase = object : SessionUseCases.LoadUrlUseCase {
@@ -171,12 +172,12 @@ class AwesomeBarView(
                 )
         }
 
+        searchSuggestionProviderMap = HashMap()
         searchShortcutsButton.setOnClickListener {
             interactor.onSearchShortcutsButtonClicked()
         }
     }
 
-    @SuppressWarnings("ComplexMethod")
     fun update(state: SearchFragmentState) {
         updateSearchShortcutsIcon(state)
 
@@ -201,69 +202,99 @@ class AwesomeBarView(
         }
     }
 
-    @Suppress("ComplexMethod")
     private fun updateSuggestionProvidersVisibility(state: SearchFragmentState) {
-        val providersToAdd = mutableSetOf<AwesomeBar.SuggestionProvider>()
-        val providersToRemove = mutableSetOf<AwesomeBar.SuggestionProvider>()
-
         if (state.showSearchShortcuts) {
             handleDisplayShortcutsProviders()
             return
         }
 
-        providersToRemove.add(shortcutsEnginePickerProvider)
+        val providersToAdd = getProvidersToAdd(state)
+        val providersToRemove = getProvidersToRemove(state)
+
+        performProviderListChanges(providersToAdd, providersToRemove)
+    }
+
+    private fun performProviderListChanges(
+        providersToAdd: MutableSet<AwesomeBar.SuggestionProvider>,
+        providersToRemove: MutableSet<AwesomeBar.SuggestionProvider>
+    ) {
+        for (provider in providersToAdd) {
+            if (providersInUse.find { it.id == provider.id } == null) {
+                providersInUse.add(provider)
+                view.addProviders(provider)
+            }
+        }
+
+        for (provider in providersToRemove) {
+            if (providersInUse.find { it.id == provider.id } != null) {
+                providersInUse.remove(provider)
+                view.removeProviders(provider)
+            }
+        }
+    }
+
+    private fun getProvidersToAdd(state: SearchFragmentState): MutableSet<AwesomeBar.SuggestionProvider> {
+        val providersToAdd = mutableSetOf<AwesomeBar.SuggestionProvider>()
 
         if (state.showHistorySuggestions) {
             providersToAdd.add(historyStorageProvider)
-        } else {
-            providersToRemove.add(historyStorageProvider)
         }
 
         if (state.showBookmarkSuggestions) {
             providersToAdd.add(bookmarksStorageSuggestionProvider)
-        } else {
-            providersToRemove.add(bookmarksStorageSuggestionProvider)
         }
 
         if (state.showSearchSuggestions) {
-            providersToAdd.add(
+            getSelectedSearchSuggestionProvider(state)?.let {
-                when (state.searchEngineSource) {
+                providersToAdd.add(it)
-                    is SearchEngineSource.Default -> defaultSearchSuggestionProvider
+            }
-                    is SearchEngineSource.Shortcut -> createSuggestionProviderForEngine(
-                        state.searchEngineSource.searchEngine
-                    )
-                }
-            )
-        } else {
-            providersToRemove.add(
-                when (state.searchEngineSource) {
-                    is SearchEngineSource.Default -> defaultSearchSuggestionProvider
-                    is SearchEngineSource.Shortcut -> createSuggestionProviderForEngine(
-                        state.searchEngineSource.searchEngine
-                    )
-                }
-            )
         }
 
-        if ((container.context.asActivity() as? HomeActivity)?.browsingModeManager?.mode?.isPrivate == false) {
+        if (!isBrowsingModePrivate()) {
             providersToAdd.add(sessionProvider)
-        } else {
-            providersToRemove.add(sessionProvider)
         }
 
-        for (provider in providersToAdd) {
+        return providersToAdd
-            if (providersInUse.find { it.id == provider.id } == null) {
+    }
-                providersInUse.add(provider)
+
-                view.addProviders(provider)
+    private fun getProvidersToRemove(state: SearchFragmentState): MutableSet<AwesomeBar.SuggestionProvider> {
-            }
+        val providersToRemove = mutableSetOf<AwesomeBar.SuggestionProvider>()
+
+        providersToRemove.add(shortcutsEnginePickerProvider)
+
+        if (!state.showHistorySuggestions) {
+            providersToRemove.add(historyStorageProvider)
         }
 
-        for (provider in providersToRemove) {
+        if (!state.showBookmarkSuggestions) {
-            if (providersInUse.find { it.id == provider.id } != null) {
+            providersToRemove.add(bookmarksStorageSuggestionProvider)
-                providersInUse.remove(provider)
+        }
-                view.removeProviders(provider)
+
+        if (!state.showSearchSuggestions) {
+            getSelectedSearchSuggestionProvider(state)?.let {
+                providersToRemove.add(it)
             }
         }
+
+        if (isBrowsingModePrivate()) {
+            providersToRemove.add(sessionProvider)
+        }
+
+        return providersToRemove
+    }
+
+    private fun isBrowsingModePrivate(): Boolean {
+        return (container.context.asActivity() as? HomeActivity)?.browsingModeManager?.mode?.isPrivate
+            ?: false
+    }
+
+    private fun getSelectedSearchSuggestionProvider(state: SearchFragmentState): SearchSuggestionProvider? {
+        return when (state.searchEngineSource) {
+            is SearchEngineSource.Default -> defaultSearchSuggestionProvider
+            is SearchEngineSource.Shortcut -> getSuggestionProviderForEngine(
+                state.searchEngineSource.searchEngine
+            )
+        }
     }
 
     private fun handleDisplayShortcutsProviders() {
@@ -273,19 +304,28 @@ class AwesomeBarView(
         view.addProviders(shortcutsEnginePickerProvider)
     }
 
-    private fun createSuggestionProviderForEngine(engine: SearchEngine): SearchSuggestionProvider {
+    private fun getSuggestionProviderForEngine(engine: SearchEngine): SearchSuggestionProvider? {
-        return with(container.context) {
+        if (!searchSuggestionProviderMap.containsKey(engine)) {
-            val draw = getDrawable(R.drawable.ic_search)
+            with(container.context) {
-            draw?.colorFilter = PorterDuffColorFilter(getColorFromAttr(R.attr.primaryText), SRC_IN)
+                val draw = getDrawable(R.drawable.ic_search)
-
+                draw?.colorFilter =
-            SearchSuggestionProvider(
+                    PorterDuffColorFilter(getColorFromAttr(R.attr.primaryText), SRC_IN)
-                components.search.searchEngineManager.getDefaultSearchEngine(this, engine.name),
+
-                shortcutSearchUseCase,
+                searchSuggestionProviderMap.put(
-                components.core.client,
+                    engine, SearchSuggestionProvider(
-                limit = 3,
+                        components.search.searchEngineManager.getDefaultSearchEngine(
-                mode = SearchSuggestionProvider.Mode.MULTIPLE_SUGGESTIONS,
+                            this,
-                icon = draw?.toBitmap()
+                            engine.name
-            )
+                        ),
+                        shortcutSearchUseCase,
+                        components.core.client,
+                        limit = 3,
+                        mode = SearchSuggestionProvider.Mode.MULTIPLE_SUGGESTIONS,
+                        icon = draw?.toBitmap()
+                    )
+                )
+            }
         }
+        return searchSuggestionProviderMap[engine]
     }
 }