Feature/home screen call to action (#304)

* Add permission required to create home screen shortcuts

* Add class to allow downloading favicons

* Add "add to home" functionality as a first pass.

* Choose better shortcut title; appropriately enable/disable menu item

* Add support for two distinct layout states; browser and blank tab

These have slightly different requirements in terms of their scroll-observing behaviours. We do want the browser layout mode to respect the toolbar scrolling for instance, but we don't want the same behaviour for the new tab view. Trying to use the same `app:layout_behavior="@string/appbar_scrolling_view_behavior"` behaviour in both modes means that the new tab layout is essentially forced off screen vertically and it makes it difficult to add a button that anchors to the bottom.

Splitting these into two distinct modes lets us better control both modes without trying to find one set of views and flags which works well enough for both.

* Further work on UX of call to action; wired to show screen when clicked

* Rename "time based" feature analyzer class to something more generic

* Add in feature for home screen call to action

* Only show call to action at appropriate time for active variants

* Remove "add to home" commits

* Improve testing to ensure user dismissing c2a doesn't impact banner

* Add static import for better readability

* Undoing rename of dagger parameter

* Remove unused function

* Add light ripple effect to call to action

* Code formatting

* Adding activity transition for call to action

* Upgrading tooling

* Add fix to ensure only Nougat or newer devices get experiment

* Fix centering of call to action button

* Add correct menu reference for tools:menu link

* Move new tab layout into its own layout file

* Programmatically hide DDG logo when there's not enough space for it

* Layout tweaks around call to action button

* Add @synchronized to getVariant to prevent concurrent allocations

* Tweaking animations and minor UI changes to call to action

* Formatting

* Fix ddgLogo visibility problem after setting DDG as default browser

* Add comment to an otherwise unclear piece of code

* Add new default browser illustrations

* Configure variants

Author: CDRussell

app/src/androidTest/java/com/duckduckgo/app/browser/defaultBrowsing/DefaultBrowserTimeBasedNotificationTest.kt renamed to app/src/androidTest/java/com/duckduckgo/app/browser/defaultBrowsing/DefaultBrowserBannerNotificationTest.kt

@@ -19,7 +19,7 @@ package com.duckduckgo.app.browser.defaultBrowsing
 import com.duckduckgo.app.global.install.AppInstallStore
 import com.duckduckgo.app.statistics.Variant
 import com.duckduckgo.app.statistics.VariantManager
-import com.duckduckgo.app.statistics.VariantManager.VariantFeature.DefaultBrowserFeature.ShowTimedReminder
+import com.duckduckgo.app.statistics.VariantManager.VariantFeature.DefaultBrowserFeature.ShowBanner
 import com.nhaarman.mockito_kotlin.mock
 import com.nhaarman.mockito_kotlin.whenever
 import org.junit.Assert.assertFalse
@@ -28,7 +28,7 @@ import org.junit.Before
 import org.junit.Test
 import java.util.concurrent.TimeUnit
 
-class DefaultBrowserTimeBasedNotificationTest {
+class DefaultBrowserBannerNotificationTest {
 
     private lateinit var testee: DefaultBrowserTimeBasedNotification
 
@@ -44,48 +44,55 @@ class DefaultBrowserTimeBasedNotificationTest {
     @Test
     fun whenDefaultBrowserNotSupportedByDeviceThenNotificationNotShown() {
         configureEnvironment(false, true, true, false)
-        assertFalse(testee.shouldShowNotification(browserShowing = true))
+        assertFalse(testee.shouldShowBannerNotification(browserShowing = true))
     }
 
     @Test
     fun whenDefaultBrowserFeatureNotSupportedThenNotificationNotShown() {
         configureEnvironment(true, false, true, false)
-        assertFalse(testee.shouldShowNotification(browserShowing = true))
+        assertFalse(testee.shouldShowBannerNotification(browserShowing = true))
     }
 
     @Test
     fun whenNoAppInstallTimeRecordedThenNotificationNotShown() {
         configureEnvironment(true, true, false, false)
-        assertFalse(testee.shouldShowNotification(browserShowing = true))
+        assertFalse(testee.shouldShowBannerNotification(browserShowing = true))
     }
 
     @Test
     fun whenUserDeclinedPreviouslyThenNotificationNotShown() {
         configureEnvironment(true, true, true, true)
-        assertFalse(testee.shouldShowNotification(browserShowing = true))
+        assertFalse(testee.shouldShowBannerNotification(browserShowing = true))
     }
 
     @Test
     fun whenNotEnoughTimeHasPassedSinceInstallThenNotificationNotShown() {
         configureEnvironment(true, true, true, false)
         whenever(appInstallStore.installTimestamp).thenReturn(0)
-        assertFalse(testee.shouldShowNotification(browserShowing = true, timeNow = TimeUnit.SECONDS.toMillis(10)))
+        assertFalse(testee.shouldShowBannerNotification(browserShowing = true, timeNow = TimeUnit.SECONDS.toMillis(10)))
     }
 
     @Test
     fun whenEnoughTimeHasPassedSinceInstallThenNotificationShown() {
         configureEnvironment(true, true, true, false)
         whenever(appInstallStore.installTimestamp).thenReturn(0)
-        assertTrue(testee.shouldShowNotification(browserShowing = true, timeNow = TimeUnit.DAYS.toMillis(100)))
+        assertTrue(testee.shouldShowBannerNotification(browserShowing = true, timeNow = TimeUnit.DAYS.toMillis(100)))
+    }
+
+    @Test
+    fun whenUserDeclinedHomeScreenCallToActionPreviouslyThenNotificationStillShown() {
+        configureEnvironment(true, true, true, false)
+        whenever(appInstallStore.hasUserDeclinedDefaultBrowserHomeScreenCallToActionPreviously()).thenReturn(true)
+        assertTrue(testee.shouldShowBannerNotification(browserShowing = true))
     }
 
     private fun configureEnvironment(deviceSupported: Boolean, featureEnabled: Boolean, timestampRecorded: Boolean, previousDecline: Boolean) {
         whenever(mockDetector.deviceSupportsDefaultBrowserConfiguration()).thenReturn(deviceSupported)
         whenever(variantManager.getVariant()).thenReturn(if (featureEnabled) variantWithFeatureEnabled() else variantWithFeatureDisabled())
         whenever(appInstallStore.hasInstallTimestampRecorded()).thenReturn(timestampRecorded)
-        whenever(appInstallStore.hasUserDeclinedDefaultBrowserPreviously()).thenReturn(previousDecline)
+        whenever(appInstallStore.hasUserDeclinedDefaultBrowserBannerPreviously()).thenReturn(previousDecline)
     }
 
-    private fun variantWithFeatureEnabled() = Variant("", 0.0, listOf(ShowTimedReminder))
+    private fun variantWithFeatureEnabled() = Variant("", 0.0, listOf(ShowBanner))
     private fun variantWithFeatureDisabled() = Variant("", 0.0, listOf())
 }

app/src/androidTest/java/com/duckduckgo/app/browser/defaultBrowsing/DefaultBrowserHomeScreenCallToActionTest.kt

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2018 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.duckduckgo.app.browser.defaultBrowsing
+
+import com.duckduckgo.app.global.install.AppInstallStore
+import com.duckduckgo.app.statistics.Variant
+import com.duckduckgo.app.statistics.VariantManager
+import com.duckduckgo.app.statistics.VariantManager.VariantFeature.DefaultBrowserFeature.ShowHomeScreenCallToAction
+import com.nhaarman.mockito_kotlin.mock
+import com.nhaarman.mockito_kotlin.whenever
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class DefaultBrowserHomeScreenCallToActionTest {
+
+    private lateinit var testee: DefaultBrowserTimeBasedNotification
+
+    private val mockDetector: DefaultBrowserDetector = mock()
+    private val appInstallStore: AppInstallStore = mock()
+    private val variantManager: VariantManager = mock()
+
+    @Before
+    fun setup() {
+        testee = DefaultBrowserTimeBasedNotification(mockDetector, appInstallStore, variantManager)
+    }
+
+    @Test
+    fun whenDefaultBrowserNotSupportedByDeviceThenCallToActionNotShown() {
+        configureEnvironment(false, true, true, false)
+        assertFalse(testee.shouldShowHomeScreenCallToActionNotification())
+    }
+
+    @Test
+    fun whenDefaultBrowserFeatureNotSupportedThenCallToActionNotShown() {
+        configureEnvironment(true, false, true, false)
+        assertFalse(testee.shouldShowHomeScreenCallToActionNotification( ))
+    }
+
+    @Test
+    fun whenNoAppInstallTimeRecordedThenCallToActionNotShown() {
+        configureEnvironment(true, true, false, false)
+        assertFalse(testee.shouldShowHomeScreenCallToActionNotification( ))
+    }
+
+    @Test
+    fun whenUserDeclinedPreviouslyThenCallToActionNotShown() {
+        configureEnvironment(true, true, true, true)
+        assertFalse(testee.shouldShowHomeScreenCallToActionNotification( ))
+    }
+
+    @Test
+    fun whenAllOtherConditionsPassThenCallToActionShown() {
+        configureEnvironment(true, true, true, false)
+        whenever(appInstallStore.installTimestamp).thenReturn(0)
+        assertTrue(testee.shouldShowHomeScreenCallToActionNotification())
+    }
+
+    private fun configureEnvironment(deviceSupported: Boolean, featureEnabled: Boolean, timestampRecorded: Boolean, previousDecline: Boolean) {
+        whenever(mockDetector.deviceSupportsDefaultBrowserConfiguration()).thenReturn(deviceSupported)
+        whenever(variantManager.getVariant()).thenReturn(if (featureEnabled) variantWithFeatureEnabled() else variantWithFeatureDisabled())
+        whenever(appInstallStore.hasInstallTimestampRecorded()).thenReturn(timestampRecorded)
+        whenever(appInstallStore.hasUserDeclinedDefaultBrowserHomeScreenCallToActionPreviously()).thenReturn(previousDecline)
+    }
+
+    private fun variantWithFeatureEnabled() = Variant("", 0.0, listOf(ShowHomeScreenCallToAction))
+    private fun variantWithFeatureDisabled() = Variant("", 0.0, listOf())
+}

app/src/androidTest/java/com/duckduckgo/app/global/install/AppInstallSharedPreferencesTest.kt

@@ -36,8 +36,13 @@ class AppInstallSharedPreferencesTest {
     }
 
     @Test
-    fun whenInitializedThenUserHasNotBeenMarkedAsHavingPreviouslyDeclined() {
-        assertFalse(testee.hasUserDeclinedDefaultBrowserPreviously())
+    fun whenInitializedThenUserHasNotBeenMarkedAsHavingPreviouslyDeclinedBanner() {
+        assertFalse(testee.hasUserDeclinedDefaultBrowserBannerPreviously())
+    }
+
+    @Test
+    fun whenInitializedThenUserHasNotBeenMarkedAsHavingPreviouslyDeclinedHomeScreenCallToAction() {
+        assertFalse(testee.hasUserDeclinedDefaultBrowserHomeScreenCallToActionPreviously())
     }
 
     @Test
@@ -60,15 +65,17 @@ class AppInstallSharedPreferencesTest {
     }
 
     @Test
-    fun whenUserPreviouslyDeclinedThenThatIsReturnedWhenQueried() {
+    fun whenUserPreviouslyDeclinedBannerThenThatIsReturnedWhenQueried() {
         val timestamp = 1L
-        testee.recordUserDeclinedToSetDefaultBrowser(timestamp)
-        assertTrue(testee.hasUserDeclinedDefaultBrowserPreviously())
+        testee.recordUserDeclinedBannerToSetDefaultBrowser(timestamp)
+        assertTrue(testee.hasUserDeclinedDefaultBrowserBannerPreviously())
     }
 
     @Test
-    fun whenUserNotPreviouslyDeclinedThenThatIsReturnedWhenQueried() {
-        assertFalse(testee.hasUserDeclinedDefaultBrowserPreviously())
+    fun whenUserPreviouslyDeclinedHomeScreenCallToActionThenThatIsReturnedWhenQueried() {
+        val timestamp = 1L
+        testee.recordUserDeclinedHomeScreenCallToActionToSetDefaultBrowser(timestamp)
+        assertTrue(testee.hasUserDeclinedDefaultBrowserHomeScreenCallToActionPreviously())
     }
 
 }

app/src/androidTest/java/com/duckduckgo/app/statistics/ExperimentationVariantManagerTest.kt

@@ -16,6 +16,8 @@
 
 package com.duckduckgo.app.statistics
 
+import android.os.Build
+import android.support.test.filters.SdkSuppress
 import com.duckduckgo.app.statistics.store.StatisticsDataStore
 import com.nhaarman.mockito_kotlin.*
 import org.junit.Assert.assertEquals
@@ -93,7 +95,8 @@ class ExperimentationVariantManagerTest {
 
 
     @Test
-    fun whenNoVariantPersistedThenNewVariantAllocated() {
+    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.N)
+    fun whenNougatOrLaterAndNoVariantPersistedThenNewVariantAllocated() {
         activeVariants.add(Variant("foo", 100.0))
 
         testee.getVariant(activeVariants)
@@ -102,11 +105,30 @@ class ExperimentationVariantManagerTest {
     }
 
     @Test
-    fun whenNoVariantPersistedThenNewVariantKeyIsAllocatedAndPersisted() {
+    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.N)
+    fun whenNougatOrLaterAndNoVariantPersistedThenNewVariantKeyIsAllocatedAndPersisted() {
         activeVariants.add(Variant("foo", 100.0))
 
         testee.getVariant(activeVariants)
 
         verify(mockStore).variant = "foo"
     }
+
+    @Test
+    @SdkSuppress(maxSdkVersion = Build.VERSION_CODES.M)
+    fun whenMarshmallowOrEarlierAndNoVariantPersistedThenDefaultVariantAllocated() {
+        activeVariants.add(Variant("foo", 100.0))
+
+        assertEquals(VariantManager.DEFAULT_VARIANT, testee.getVariant(activeVariants))
+    }
+
+    @Test
+    @SdkSuppress(maxSdkVersion = Build.VERSION_CODES.M)
+    fun whenMarshmallowOrEarlierAndNoVariantPersistedThenDefaultVariantKeyIsAllocatedAndPersisted() {
+        activeVariants.add(Variant("foo", 100.0))
+
+        testee.getVariant(activeVariants)
+
+        verify(mockStore).variant = VariantManager.DEFAULT_VARIANT.key
+    }
 }

app/src/androidTest/java/com/duckduckgo/app/statistics/VariantManagerTest.kt

@@ -16,8 +16,8 @@
 
 package com.duckduckgo.app.statistics
 
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.fail
+import com.duckduckgo.app.statistics.VariantManager.VariantFeature.DefaultBrowserFeature.*
+import org.junit.Assert.*
 import org.junit.Test
 
 class VariantManagerTest {
@@ -26,24 +26,43 @@ class VariantManagerTest {
     private val totalWeight = variants.sumByDouble { it.weight }
 
     @Test
-    fun whenChanceOfControlVariantCalculatedThenOddsAreOneInTwo() {
-        val variant = variants.firstOrNull { it.key == "my" }
-        assertNotNull(variant)
-        assertEqualsDouble( 0.5, variant!!.weight / totalWeight)
+    fun onboardingOnlyVariantConfiguredCorrectly() {
+        val variant = variants.firstOrNull { it.key == "ms" }
+        assertEqualsDouble( 0.20, variant!!.weight / totalWeight)
+        assertTrue(variant.hasFeature(ShowInOnboarding))
+        assertEquals(1, variant.features.size)
+    }
+
+    @Test
+    fun homeScreenCallToActionVariantConfiguredCorrectly() {
+        val variant = variants.firstOrNull { it.key == "mt" }
+        assertEqualsDouble( 0.20, variant!!.weight / totalWeight)
+        assertTrue(variant.hasFeature(ShowHomeScreenCallToAction))
+        assertEquals(1, variant.features.size)
     }
 
     @Test
-    fun whenChanceOfOnboardingOnlyVariantCalculatedThenOddsAreOneInFour() {
-        val variant = variants.firstOrNull { it.key == "mw" }
-        assertNotNull(variant)
-        assertEqualsDouble( 0.25, variant!!.weight / totalWeight)
+    fun showBannerVariantConfiguredCorrectly() {
+        val variant = variants.firstOrNull { it.key == "mu" }
+        assertEqualsDouble( 0.20, variant!!.weight / totalWeight)
+        assertTrue(variant.hasFeature(ShowBanner))
+        assertEquals(1, variant.features.size)
     }
 
     @Test
-    fun whenChanceOfOnboardingAndReminderVariantCalculatedThenOddsAreOneInFour() {
-        val variant = variants.firstOrNull { it.key == "mx" }
-        assertNotNull(variant)
-        assertEqualsDouble( 0.25, variant!!.weight / totalWeight)
+    fun showBannerAndShowHomeScreenCallToActionVariantConfiguredCorrectly() {
+        val variant = variants.firstOrNull { it.key == "mv" }
+        assertEqualsDouble( 0.20, variant!!.weight / totalWeight)
+        assertTrue(variant.hasFeature(ShowBanner))
+        assertTrue(variant.hasFeature(ShowHomeScreenCallToAction))
+        assertEquals(2, variant.features.size)
+    }
+
+    @Test
+    fun controlVariantConfiguredCorrectly() {
+        val variant = variants.firstOrNull { it.key == "my" }
+        assertEqualsDouble( 0.2, variant!!.weight / totalWeight)
+        assertEquals(0, variant.features.size)
     }
 
     private fun assertEqualsDouble(expected: Double, actual: Double) {