Quick Win: Android: Sharing from Google Discover Feed to DDG Browser (news) v2 (#6846)

Task/Issue URL:
https://app.asana.com/1/137249556945/project/715106103902962/task/1211097615118449?focus=true

### Description
Improved URL extraction from user queries by handling special characters
and formatting. The changes allow the app to extract URLs from text that
contains apostrophes, double quotes, and new lines.

### Steps to test this PR

Tests should pass.

- [x] Install from this branch.
- [x] Use the share button from the Google Discover and share with the
installed DuckDuckGo.
- [x] Notice the websites are opened as expected.

### NO UI changes

Author: anikiki

app/src/test/java/com/duckduckgo/app/browser/QueryUrlConverterTest.kt

@@ -38,20 +38,20 @@ import org.mockito.kotlin.whenever
 @RunWith(AndroidJUnit4::class)
 @SuppressLint("DenyListedApi") // fake toggle store
 class QueryUrlConverterTest {
-
     private var mockStatisticsStore: StatisticsDataStore = mock()
     private val variantManager: VariantManager = mock()
     private val mockAppReferrerDataStore: AppReferrerDataStore = mock()
     private val duckChat: DuckChat = mock()
     private val androidBrowserConfigFeature: AndroidBrowserConfigFeature = FakeFeatureToggleFactory.create(AndroidBrowserConfigFeature::class.java)
-    private val requestRewriter = DuckDuckGoRequestRewriter(
-        DuckDuckGoUrlDetectorImpl(),
-        mockStatisticsStore,
-        variantManager,
-        mockAppReferrerDataStore,
-        duckChat,
-        androidBrowserConfigFeature,
-    )
+    private val requestRewriter =
+        DuckDuckGoRequestRewriter(
+            DuckDuckGoUrlDetectorImpl(),
+            mockStatisticsStore,
+            variantManager,
+            mockAppReferrerDataStore,
+            duckChat,
+            androidBrowserConfigFeature,
+        )
     private val testee: QueryUrlConverter = QueryUrlConverter(requestRewriter)
 
     @Before
@@ -172,6 +172,41 @@ class QueryUrlConverterTest {
         assertEquals("https://search.app/2W427", result)
     }
 
+    @Test
+    fun whenQueryContainsMultipleUrlsThenFirstUrlStartingWithHttpIsExtracted() {
+        val input = "Source: MTBS.cz  https://search.app/3Uq79"
+        val result = testee.convertQueryToUrl(input, queryOrigin = QueryOrigin.FromUser, extractUrlFromQuery = true)
+        assertEquals("https://search.app/3Uq79", result)
+    }
+
+    @Test
+    fun whenQueryContainsSingleUrlAndApostropheThenUrlIsExtracted() {
+        val input = "Source: Tom's Guide https://search.app/ddbWi"
+        val result = testee.convertQueryToUrl(input, queryOrigin = QueryOrigin.FromUser, extractUrlFromQuery = true)
+        assertEquals("https://search.app/ddbWi", result)
+    }
+
+    @Test
+    fun whenQueryContainsSingleUrlAndDoubleQuotesThenUrlIsExtracted() {
+        val input =
+            """
+            Source: "Guide" https://search.app/ddbWi
+            """.trimIndent()
+        val result = testee.convertQueryToUrl(input, queryOrigin = QueryOrigin.FromUser, extractUrlFromQuery = true)
+        assertEquals("https://search.app/ddbWi", result)
+    }
+
+    @Test
+    fun whenQueryContainsSingleUrlAndNewLineThenUrlIsExtracted() {
+        val input =
+            """
+            Source:
+            Tom Guide https://search.app/ddbWi
+            """.trimIndent()
+        val result = testee.convertQueryToUrl(input, queryOrigin = QueryOrigin.FromUser, extractUrlFromQuery = true)
+        assertEquals("https://search.app/ddbWi", result)
+    }
+
     @Test
     fun whenQueryContainsSingleUrlWithNoSchemeThenUrlIsExtractedAndSchemeAdded() {
         val input = "pre text duckduckgo.com post text"
@@ -194,6 +229,7 @@ class QueryUrlConverterTest {
         val result = testee.convertQueryToUrl(input, queryOrigin = QueryOrigin.FromUser, extractUrlFromQuery = false)
         assertDuckDuckGoSearchQuery(expected, result)
     }
+
     private fun assertDuckDuckGoSearchQuery(
         query: String,
         url: String,

browser-api/src/main/java/com/duckduckgo/app/browser/UriString.kt

@@ -22,32 +22,32 @@ import androidx.core.util.PatternsCompat
 import com.duckduckgo.common.utils.UrlScheme
 import com.duckduckgo.common.utils.baseHost
 import com.duckduckgo.common.utils.withScheme
-import java.lang.IllegalArgumentException
 import logcat.LogPriority.INFO
 import logcat.logcat
 import okhttp3.HttpUrl.Companion.toHttpUrl
+import java.lang.IllegalArgumentException
 
 class UriString {
-
     companion object {
-        private const val localhost = "localhost"
-        private const val space = " "
+        private const val LOCALHOST = "localhost"
+        private const val SPACE = " "
         private val webUrlRegex by lazy { PatternsCompat.WEB_URL.toRegex() }
         private val domainRegex by lazy { PatternsCompat.DOMAIN_NAME.toRegex() }
+        private val inputQueryCleanupRegex by lazy { "['\"\n]|\\s+".toRegex() }
         private val cache = LruCache<Int, Boolean>(250_000)
 
         fun extractUrl(inputQuery: String): String? {
             val urls = webUrlRegex.findAll(inputQuery).map { it.value }.toList()
-            return if (urls.size == 1) {
-                urls.first()
-            } else {
-                null
+            return when {
+                urls.isEmpty() -> null
+                urls.size == 1 -> urls.first()
+                // If multiple URLs found and all start with http, treat this as a search.
+                urls.all { it.startsWith("http") } -> null
+                else -> urls.firstOrNull { it.startsWith("http") }
             }
         }
 
-        fun host(uriString: String): String? {
-            return Uri.parse(uriString).baseHost
-        }
+        fun host(uriString: String): String? = Uri.parse(uriString).baseHost
 
         fun sameOrSubdomain(
             child: String,
@@ -105,27 +105,31 @@ class UriString {
             return parentHost == childHost || (childHost.endsWith(".$parentHost") || parentHost.endsWith(".$childHost"))
         }
 
-        fun isWebUrl(inputQuery: String, extractUrlQuery: Boolean = false): Boolean {
-            if (inputQuery.contains("\"") || inputQuery.contains("'")) {
-                return false
-            }
-
+        fun isWebUrl(
+            inputQuery: String,
+            extractUrlQuery: Boolean = false,
+        ): Boolean {
             if (extractUrlQuery) {
-                val extractedUrl = extractUrl(inputQuery)
+                val cleanInputQuery = cleanupInputQuery(inputQuery)
+                val extractedUrl = extractUrl(cleanInputQuery)
                 if (extractedUrl != null) {
                     return isWebUrl(extractedUrl)
                 }
             }
 
-            if (inputQuery.contains(space)) return false
+            if (inputQuery.contains("\"") || inputQuery.contains("'")) {
+                return false
+            }
+
+            if (inputQuery.contains(SPACE)) return false
             val rawUri = Uri.parse(inputQuery)
 
             val uri = rawUri.withScheme()
             if (!uri.hasWebScheme()) return false
             if (uri.userInfo != null) return false
 
             val host = uri.host ?: return false
-            if (host == localhost) return true
+            if (host == LOCALHOST) return true
             if (host.contains("!")) return false
 
             if (webUrlRegex.containsMatchIn(host)) return true
@@ -144,9 +148,7 @@ class UriString {
             }
         }
 
-        fun isValidDomain(domain: String): Boolean {
-            return domainRegex.matches(domain)
-        }
+        fun isValidDomain(domain: String): Boolean = domainRegex.matches(domain)
 
         fun isDuckUri(inputQuery: String): Boolean {
             val uri = Uri.parse(inputQuery)
@@ -169,5 +171,7 @@ class UriString {
             val normalized = normalizeScheme()
             return normalized.scheme == UrlScheme.duck
         }
+
+        private fun cleanupInputQuery(text: String): String = text.replace(inputQueryCleanupRegex, " ").trim()
     }
 }