add repeat 1

Author: cmonfortep

app/src/test/java/com/duckduckgo/app/dispatchers/AutofillEffectDispatcherViewModelTest.kt renamed to app/src/test/java/com/duckduckgo/app/dispatchers/IntentDispatcherViewModelTest.kt

@@ -38,7 +38,7 @@ import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 
-class AutofillEffectDispatcherViewModelTest {
+class IntentDispatcherViewModelTest {
     @get:Rule
     val coroutineTestRule: CoroutineTestRule = CoroutineTestRule()
 

autofill/autofill-api/src/main/java/com/duckduckgo/autofill/api/AutofillFeature.kt

@@ -152,6 +152,6 @@ interface AutofillFeature {
     @Toggle.DefaultValue(defaultValue = DefaultFeatureValue.TRUE)
     fun createAsyncPreferences(): Toggle
 
-    @Toggle.DefaultValue(defaultValue = DefaultFeatureValue.TRUE)
+    @Toggle.DefaultValue(defaultValue = DefaultFeatureValue.INTERNAL)
     fun canPromoteImportPasswords(): Toggle
 }

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/SecureStoreBackedAutofillStore.kt

@@ -90,6 +90,10 @@ class SecureStoreBackedAutofillStore @Inject constructor(
             autofillPrefsStore.hasEverImportedPasswords = value
         }
 
+    override fun hasEverImportedPasswordsFlow(): Flow<Boolean> {
+        return autofillPrefsStore.hasEverImportedPasswordsFlow()
+    }
+
     override var hasDismissedImportedPasswordsPromo: Boolean
         get() = autofillPrefsStore.hasDismissedImportedPasswordsPromo
         set(value) {

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/CredentialImporter.kt

@@ -85,6 +85,12 @@ class CredentialImporterImpl @Inject constructor(
         val insertedIds = autofillStore.bulkInsert(importList)
 
         skippedCredentials += (importList.size - insertedIds.size)
+
+        // Set the flag when at least one credential was successfully imported
+        if (insertedIds.isNotEmpty()) {
+            autofillStore.hasEverImportedPasswords = true
+        }
+
         _importStatus.emit(Finished(savedCredentials = insertedIds.size, numberSkipped = skippedCredentials))
     }
 

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/promo/ImportInPasswordsPromotion.kt

@@ -129,7 +129,7 @@ class ImportInPasswordsPromotionView @JvmOverloads constructor(
                 ),
             )
             onTopAnimationConfigured { view ->
-                view.repeatCount = 2
+                view.repeatCount = 1
                 view.playAnimation()
             }
             onPrimaryActionClicked {

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/promo/ImportInPasswordsPromotionViewModel.kt

@@ -26,7 +26,6 @@ import com.duckduckgo.autofill.impl.pixel.AutofillPixelNames
 import com.duckduckgo.autofill.impl.pixel.AutofillPixelNames.AUTOFILL_IMPORT_GOOGLE_PASSWORDS_EMPTY_STATE_CTA_BUTTON_TAPPED
 import com.duckduckgo.autofill.impl.store.AutofillEffect
 import com.duckduckgo.autofill.impl.store.AutofillEffectDispatcher
-import com.duckduckgo.autofill.impl.store.InternalAutofillStore
 import com.duckduckgo.common.utils.DispatcherProvider
 import com.duckduckgo.di.scopes.ViewScope
 import javax.inject.Inject
@@ -40,8 +39,8 @@ import kotlinx.coroutines.launch
 class ImportInPasswordsPromotionViewModel @Inject constructor(
     private val pixel: Pixel,
     private val dispatchers: DispatcherProvider,
-    private val internalAutofillStore: InternalAutofillStore,
     private val promoEventDispatcher: AutofillEffectDispatcher,
+    private val importInPasswordsVisibility: ImportInPasswordsVisibility,
 ) : ViewModel() {
 
     sealed interface Command {
@@ -76,7 +75,7 @@ class ImportInPasswordsPromotionViewModel @Inject constructor(
 
     fun onUserDismissedPromo() {
         viewModelScope.launch(dispatchers.io()) {
-            internalAutofillStore.hasDismissedImportedPasswordsPromo = true
+            importInPasswordsVisibility.onPromoDismissed()
             command.send(DismissImport)
         }
     }

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/importing/promo/ImportInPasswordsVisibility.kt

@@ -25,16 +25,20 @@ import com.duckduckgo.autofill.impl.store.InternalAutofillStore
 import com.duckduckgo.common.utils.DispatcherProvider
 import com.duckduckgo.di.scopes.AppScope
 import com.squareup.anvil.annotations.ContributesBinding
+import dagger.SingleInstanceIn
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
 import logcat.logcat
 
 interface ImportInPasswordsVisibility {
     fun canShowImportInPasswords(numberSavedPasswords: Int): Boolean
+    fun onPromoDismissed()
 }
 
 @ContributesBinding(AppScope::class)
+@SingleInstanceIn(AppScope::class)
 class RealImportInPasswordsVisibility @Inject constructor(
     private val internalAutofillStore: InternalAutofillStore,
     private val autofillFeature: AutofillFeature,
@@ -50,6 +54,17 @@ class RealImportInPasswordsVisibility @Inject constructor(
             logcat { "Autofill: Evaluating if user can show import promo" }
             canShowImportPasswords = evaluateIfUserCanShowImportPromo()
             logcat { "Autofill: Evaluation result, can show import promo? $canShowImportPasswords" }
+
+            if (!canShowImportPasswords) return@launch
+
+            // Observe changes of hasEverImportedPasswordsFlow only if the promo can be shown
+            internalAutofillStore.hasEverImportedPasswordsFlow().collect { hasImported ->
+                logcat { "Autofill: hasEverImportedPasswords changed to $hasImported" }
+                if (hasImported) {
+                    canShowImportPasswords = false
+                    logcat { "Autofill: User has imported passwords, hiding promo" }
+                }
+            }
         }
     }
 
@@ -58,6 +73,11 @@ class RealImportInPasswordsVisibility @Inject constructor(
         return canShowImportPasswords
     }
 
+    override fun onPromoDismissed() {
+        internalAutofillStore.hasDismissedImportedPasswordsPromo = true
+        canShowImportPasswords = false
+    }
+
     private suspend fun evaluateIfUserCanShowImportPromo(): Boolean {
         if (autofillFeature.canPromoteImportPasswords().isEnabled().not()) return false
 

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/impl/store/InternalAutofillStore.kt

@@ -42,6 +42,8 @@ interface InternalAutofillStore : AutofillStore {
 
     var hasEverImportedPasswords: Boolean
 
+    fun hasEverImportedPasswordsFlow(): Flow<Boolean>
+
     var hasDismissedImportedPasswordsPromo: Boolean
 
     /**

autofill/autofill-impl/src/main/java/com/duckduckgo/autofill/store/AutofillPrefsStore.kt

@@ -21,6 +21,10 @@ import android.content.Context
 import android.content.SharedPreferences
 import androidx.core.content.edit
 import com.duckduckgo.autofill.store.feature.AutofillDefaultStateDecider
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.onStart
 import logcat.LogPriority.INFO
 import logcat.logcat
 
@@ -30,6 +34,7 @@ interface AutofillPrefsStore {
     var monitorDeclineCounts: Boolean
     var hasEverBeenPromptedToSaveLogin: Boolean
     var hasEverImportedPasswords: Boolean
+    fun hasEverImportedPasswordsFlow(): Flow<Boolean>
     var hasDismissedImportedPasswordsPromo: Boolean
     val autofillStateSetByUser: Boolean
     var timestampUserLastPromptedToDisableAutofill: Long?
@@ -60,6 +65,8 @@ class RealAutofillPrefsStore(
         applicationContext.getSharedPreferences(FILENAME, Context.MODE_PRIVATE)
     }
 
+    private val hasEverImportedPasswordsFlow = MutableSharedFlow<Boolean>(replay = 1)
+
     override var isEnabled: Boolean
         get(): Boolean {
             // if autofill state has been manually set by user, honor that
@@ -87,7 +94,16 @@ class RealAutofillPrefsStore(
 
     override var hasEverImportedPasswords: Boolean
         get() = prefs.getBoolean(HAS_EVER_IMPORT_PASSWORDS, false)
-        set(value) = prefs.edit { putBoolean(HAS_EVER_IMPORT_PASSWORDS, value) }
+        set(value) {
+            prefs.edit { putBoolean(HAS_EVER_IMPORT_PASSWORDS, value) }
+            hasEverImportedPasswordsFlow.tryEmit(value)
+        }
+
+    override fun hasEverImportedPasswordsFlow(): Flow<Boolean> {
+        return hasEverImportedPasswordsFlow
+            .onStart { emit(hasEverImportedPasswords) }
+            .distinctUntilChanged()
+    }
 
     override var hasDismissedImportedPasswordsPromo: Boolean
         get() = prefs.getBoolean(HAS_DISMISSED_IMPORT_PASSWORDS_PROMO, false)

autofill/autofill-impl/src/test/java/com/duckduckgo/autofill/impl/importing/CredentialImporterImplTest.kt

@@ -6,23 +6,25 @@ import com.duckduckgo.autofill.impl.importing.CredentialImporter.ImportResult
 import com.duckduckgo.autofill.impl.store.InternalAutofillStore
 import com.duckduckgo.common.test.CoroutineTestRule
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.test.StandardTestDispatcher
-import kotlinx.coroutines.test.TestCoroutineScheduler
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
 class CredentialImporterImplTest {
+
     @get:Rule
-    val coroutineTestRule: CoroutineTestRule = CoroutineTestRule(StandardTestDispatcher(TestCoroutineScheduler()))
+    var coroutinesTestRule = CoroutineTestRule()
+
     private val autofillStore: InternalAutofillStore = mock()
-    private val dispatchers = coroutineTestRule.testDispatcherProvider
-    private val appCoroutineScope: CoroutineScope = coroutineTestRule.testScope
+    private val dispatchers = coroutinesTestRule.testDispatcherProvider
+    private val appCoroutineScope: CoroutineScope = coroutinesTestRule.testScope
 
     private val credentialsAlreadyInDb = mutableListOf<LoginCredentials>()
 
@@ -110,6 +112,26 @@ class CredentialImporterImplTest {
         assertResult(numberSkippedExpected = 2, importListSizeExpected = 1)
     }
 
+    @Test
+    fun whenImportingCredentialsSuccessfullyThenHasEverImportedPasswordsIsSetToTrue() = runTest {
+        listOf(creds()).import()
+        verify(autofillStore).hasEverImportedPasswords = true
+    }
+
+    @Test
+    fun whenImportingNoCredentialsThenHasEverImportedPasswordsIsNotSet() = runTest {
+        listOf<LoginCredentials>().import()
+        verify(autofillStore, never()).hasEverImportedPasswords = true
+    }
+
+    @Test
+    fun whenImportingOnlyDuplicatesThenHasEverImportedPasswordsIsNotSet() = runTest {
+        val duplicatedLogin = creds(username = "username")
+        duplicatedLogin.treatAsDuplicate()
+        listOf(duplicatedLogin).import()
+        verify(autofillStore, never()).hasEverImportedPasswords = true
+    }
+
     private suspend fun List<LoginCredentials>.import(originalListSize: Int = this.size) {
         testee.import(this, originalListSize)
     }
@@ -119,7 +141,6 @@ class CredentialImporterImplTest {
         importListSizeExpected: Int,
     ) {
         testee.getImportStatus().test {
-            awaitItem()
             with(awaitItem() as ImportResult.Finished) {
                 assertEquals("Wrong number of duplicates in result", numberSkippedExpected, numberSkipped)
                 assertEquals("Wrong import size in result", importListSizeExpected, savedCredentials)