Intercept sync setup URLs that are passed into our app (#6008)

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

### Description
Adds the ability for our app to consume sync pairing URLs. For context,
there are 3 main scenarios involving scanning the sync barcodes:

- the user scanned using our in-app scanner
- the user scanned using their normal camera app, and another browser is
set as default
- the user scanned using their normal camera app, and our app is the
default browser.
    - 👆 **this flow is the relevant one** that this PR adds support for.

When the user scans the sync setup barcode using their system camera app
and it's recognised as a URL, our app will be handed the `intent` for
the URL. We identify it as a sync setup URL and:
- prevent it from launching inside a custom tab
- prevent it from loading as a normal webview load in a tab
- launch the sync setup flow

The sync setup flow begins with a prompt to ensure the user is intending
to set up syncing with another device.
<img
src="https://github.com/user-attachments/assets/d20d0324-cd34-431c-84a3-cf24a4f0af44"
width="30%" />


### Steps to test this PR

#### Scanning a `connect` code
You'll need two devices, one of which is a physical one (to scan
barcodes). Will call these "physical device" and "other device" in the
following steps:

- [x] Fresh install on both devices, and set us up as the default
browser on the physical device
- [x] On the other device, go to sync settings and choose to `Sync With
Another Device` (`connect` code)
- [x] On the physical device, launch the system camera app. It should
recognise it as a URL and let you tap to launch it.
- [x] Verify it launches into us prompting you to confirm you want to
`Sync new device?`
- [x] Choose `Cancel`, and verify you're left on the `Sync Settings`
page
- [x] Scan it again from the system camera app and this time confirm you
do want to sync with the new device
- [x] Verify you see the "setting up" screen and that sync successfully
is set up

#### Scanning an `exchange` code

- [x] Log out on the physical device; stay logged into sync on the other
device
- [x] On the other device, go to sync settings and choose to `Sync With
Another Device` (`exchange` code)
- [x] On the physical device, launch the system camera app. It should
recognise it as a URL and let you tap to launch it.
- [x] Verify it launches into us prompting you to confirm you want to
`Sync new device?`. Say yes.
- [x] Verify you see the "setting up" screen and that sync successfully
is set up

#### Transparent sync account switching

- [x] Log out on the physical device; stay logged into sync on the other
device
- [x] On the physical device, choose `Sync and Back Up This Device` and
complete that flow. They are now on separate sync accounts.
- [x] On the other device, go to sync settings and choose to `Sync With
Another Device`
- [x] On the physical device, launch the system camera app. It should
recognise it as a URL and let you tap to launch it.
- [x] Verify it launches into us prompting you to confirm you want to
`Sync new device?`. Say yes.
- [x] Verify you see the "setting up" screen and that sync successfully
is set up

#### Prompted sync account switching
You'll need a third device this time. We'll imaginatively call this one
"third device".

- [x] Remain logged into the same account on physical device and other
device (which is the state you'll be in from last test).
- [x] On the third device, set up sync on its own account.
- so physical + other are connected; the third device is logged into a
separate sync account by itself
- [x] On the third device, go to sync settings and choose to `Sync With
Another Device`
- [x] On the physical device, launch the system camera app. It should
recognise it as a URL and let you tap to launch it.
- [x] Verify it launches into us prompting you to confirm you want to
`Sync new device?`. Say yes.
- [ ] Verify you see the "setting up" screen
- [x] Verify you are prompted to switch accounts. Agree, and verify sync
completes and you're switched over so that physical and third device are
now connected
- [x] Repeat the process but say no when prompted; verify you are
returned to the sync setup screen and your account wasn't switched.


#### Other device disappears during exchange flow

- [x] Log out on the physical device; stay logged into sync on the other
device
- [x] On the other device, go to sync settings and choose to `Sync With
Another Device` (`exchange` code)
- [x] On the physical device, launch the system camera app. It should
recognise it as a URL and let you tap to launch it.
- [x] Verify it launches into us prompting you to confirm you want to
`Sync new device?`. **Don't say yes, yet.**
- [x] On the other device, close the barcode screen
- [x] Now, on physical device, say yes to syncing that other device. 
- [x] Verify you see the "setting up" screen. But this can't succeed, so
verify after some time you see an error message.


---
- To see the specific tasks where the Asana app for GitHub is being
used, see below:
  - https://app.asana.com/0/0/1210205485995728

---------

Co-authored-by: Craig Russell <[email protected]>
Co-authored-by: Cristian Monforte <[email protected]>

Author: CDRussell

app/src/main/java/com/duckduckgo/app/browser/BrowserActivity.kt

@@ -35,7 +35,6 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.annotation.VisibleForTesting
 import androidx.core.view.isVisible
 import androidx.core.view.postDelayed
-import androidx.fragment.app.Fragment
 import androidx.lifecycle.Lifecycle.State.STARTED
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
@@ -103,6 +102,8 @@ import com.duckduckgo.duckchat.api.DuckChat
 import com.duckduckgo.navigation.api.GlobalActivityStarter
 import com.duckduckgo.savedsites.impl.bookmarks.BookmarksActivity.Companion.SAVED_SITE_URL_EXTRA
 import com.duckduckgo.site.permissions.impl.ui.SitePermissionScreenNoParams
+import com.duckduckgo.sync.api.SyncActivityFromSetupUrl
+import com.duckduckgo.sync.api.setup.SyncUrlIdentifier
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
@@ -177,6 +178,9 @@ open class BrowserActivity : DuckDuckGoActivity() {
     @Inject
     lateinit var duckChat: DuckChat
 
+    @Inject
+    lateinit var syncUrlIdentifier: SyncUrlIdentifier
+
     @Inject
     lateinit var visualDesignExperimentDataStore: VisualDesignExperimentDataStore
 
@@ -523,6 +527,14 @@ open class BrowserActivity : DuckDuckGoActivity() {
             return
         }
 
+        intent.intentText?.let {
+            if (syncUrlIdentifier.shouldDelegateToSyncSetup(it)) {
+                globalActivityStarter.start(this, SyncActivityFromSetupUrl(it))
+                logcat { "Sync setup link was consumed, so don't allow it to open in a new tab" }
+                return
+            }
+        }
+
         // the BrowserActivity will automatically clear its stack of activities when being brought to the foreground, so this can no longer be true
         currentTab?.inContextEmailProtectionShowing = false
 
@@ -1020,7 +1032,11 @@ open class BrowserActivity : DuckDuckGoActivity() {
         tabPagerAdapter.onTabsUpdated(updatedTabIds)
     }
 
-    fun launchNewTab(query: String? = null, sourceTabId: String? = null, skipHome: Boolean = false) {
+    fun launchNewTab(
+        query: String? = null,
+        sourceTabId: String? = null,
+        skipHome: Boolean = false,
+    ) {
         lifecycleScope.launch {
             if (swipingTabsFeature.isEnabled) {
                 tabManager.openNewTab(query, sourceTabId, skipHome)

app/src/main/java/com/duckduckgo/app/dispatchers/IntentDispatcherViewModel.kt

@@ -27,6 +27,7 @@ import com.duckduckgo.autofill.api.emailprotection.EmailProtectionLinkVerifier
 import com.duckduckgo.common.utils.DispatcherProvider
 import com.duckduckgo.customtabs.api.CustomTabDetector
 import com.duckduckgo.di.scopes.ActivityScope
+import com.duckduckgo.sync.api.setup.SyncUrlIdentifier
 import javax.inject.Inject
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -40,6 +41,7 @@ class IntentDispatcherViewModel @Inject constructor(
     private val dispatcherProvider: DispatcherProvider,
     private val emailProtectionLinkVerifier: EmailProtectionLinkVerifier,
     private val duckDuckGoUrlDetector: DuckDuckGoUrlDetector,
+    private val syncUrlIdentifier: SyncUrlIdentifier,
 ) : ViewModel() {
 
     private val _viewState = MutableStateFlow(ViewState())
@@ -60,7 +62,9 @@ class IntentDispatcherViewModel @Inject constructor(
                 val toolbarColor = intent?.getIntExtra(CustomTabsIntent.EXTRA_TOOLBAR_COLOR, defaultColor) ?: defaultColor
                 val isEmailProtectionLink = emailProtectionLinkVerifier.shouldDelegateToInContextView(intentText, true)
                 val isDuckDuckGoUrl = intentText?.let { duckDuckGoUrlDetector.isDuckDuckGoUrl(it) } ?: false
-                val customTabRequested = hasSession && !isEmailProtectionLink && !isDuckDuckGoUrl
+
+                val isSyncPairingUrl = syncUrlIdentifier.shouldDelegateToSyncSetup(intentText)
+                val customTabRequested = hasSession && !isEmailProtectionLink && !isDuckDuckGoUrl && !isSyncPairingUrl
 
                 logcat { "Intent $intent received. Has extra session=$hasSession. Intent text=$intentText. Toolbar color=$toolbarColor" }
 

app/src/test/java/com/duckduckgo/app/dispatchers/IntentDispatcherViewModelTest.kt

@@ -24,6 +24,8 @@ import com.duckduckgo.app.global.intentText
 import com.duckduckgo.autofill.api.emailprotection.EmailProtectionLinkVerifier
 import com.duckduckgo.common.test.CoroutineTestRule
 import com.duckduckgo.customtabs.api.CustomTabDetector
+import com.duckduckgo.sync.api.setup.SyncUrlIdentifier
+import com.duckduckgo.sync.impl.ui.qrcode.SyncBarcodeUrl
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -44,6 +46,7 @@ class IntentDispatcherViewModelTest {
     private val mockIntent: Intent = mock()
     private val emailProtectionLinkVerifier: EmailProtectionLinkVerifier = mock()
     private val duckDuckGoUrlDetector: DuckDuckGoUrlDetector = mock()
+    private val syncUrlIdentifier: SyncUrlIdentifier = mock()
 
     private lateinit var testee: IntentDispatcherViewModel
 
@@ -54,7 +57,10 @@ class IntentDispatcherViewModelTest {
             dispatcherProvider = coroutineTestRule.testDispatcherProvider,
             emailProtectionLinkVerifier = emailProtectionLinkVerifier,
             duckDuckGoUrlDetector = duckDuckGoUrlDetector,
+            syncUrlIdentifier = syncUrlIdentifier,
         )
+
+        whenever(syncUrlIdentifier.shouldDelegateToSyncSetup(anyOrNull())).thenReturn(false)
     }
 
     @Test
@@ -193,6 +199,20 @@ class IntentDispatcherViewModelTest {
         }
     }
 
+    @Test
+    fun whenIntentReceivedForSyncPairingUrlThenCustomTabIsNotRequested() = runTest {
+        val intentUrl = SyncBarcodeUrl.URL_BASE
+        whenever(mockIntent.intentText).thenReturn(intentUrl)
+        whenever(syncUrlIdentifier.shouldDelegateToSyncSetup(intentUrl)).thenReturn(true)
+        testee.onIntentReceived(mockIntent, DEFAULT_COLOR, isExternal = true)
+
+        testee.viewState.test {
+            val state = awaitItem()
+            assertFalse(state.customTabRequested)
+            assertEquals(intentUrl, state.intentText)
+        }
+    }
+
     private fun configureHasSession(returnValue: Boolean) {
         whenever(mockIntent.hasExtra(CustomTabsIntent.EXTRA_SESSION)).thenReturn(returnValue)
     }

sync/sync-api/src/main/java/com/duckduckgo/sync/api/SyncScreens.kt

@@ -25,3 +25,14 @@ import com.duckduckgo.navigation.api.GlobalActivityStarter
  * ```
  */
 object SyncActivityWithEmptyParams : GlobalActivityStarter.ActivityParams
+
+/**
+ * Use this class to launch the sync screen with a URL-based sync pairing code
+ * It is not expected that the URL would be hand-crafted
+ * This is to support the flow when a URL-based sync setup QR code is scanned using the normal camera app and we're the default browser
+ *
+ * ```kotlin
+ * globalActivityStarter.start(context, SyncActivityFromSetupUrl("https://duckduckgo.com/sync/pairing/#&code=ABC-123&deviceName=iPhone"))
+ * ```
+ */
+data class SyncActivityFromSetupUrl(val url: String) : GlobalActivityStarter.ActivityParams

sync/sync-api/src/main/java/com/duckduckgo/sync/api/setup/SyncUrlIdentifier.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2025 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.sync.api.setup
+
+/**
+ * Used to determine if the app was launched with an intent that should be delegated to sync setup flow
+ */
+interface SyncUrlIdentifier {
+
+    fun shouldDelegateToSyncSetup(intentText: String?): Boolean
+}

sync/sync-impl/build.gradle

@@ -18,6 +18,7 @@ plugins {
     id 'com.android.library'
     id 'kotlin-android'
     id 'com.squareup.anvil'
+    id 'kotlin-parcelize'
 }
 
 apply from: "$rootProject.projectDir/gradle/android-library.gradle"

sync/sync-impl/src/main/java/com/duckduckgo/sync/impl/SyncFeature.kt

@@ -59,4 +59,10 @@ interface SyncFeature {
 
     @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
     fun canScanUrlBasedSyncSetupBarcodes(): Toggle
+
+    @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
+    fun canInterceptSyncSetupUrls(): Toggle
+
+    @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
+    fun canOverrideThemeSyncSetup(): Toggle
 }

sync/sync-impl/src/main/java/com/duckduckgo/sync/impl/pixels/SyncPixelParamRemovalPlugin.kt

@@ -42,6 +42,21 @@ class SyncPixelParamRemovalPlugin @Inject constructor() : PixelParamRemovalPlugi
             SyncPixelName.SYNC_USER_SWITCHED_ACCOUNT.pixelName to PixelParameter.removeAtb(),
             SyncPixelName.SYNC_USER_SWITCHED_LOGOUT_ERROR.pixelName to PixelParameter.removeAtb(),
             SyncPixelName.SYNC_USER_SWITCHED_LOGIN_ERROR.pixelName to PixelParameter.removeAtb(),
+
+            SyncPixelName.SYNC_SETUP_DEEP_LINK_TIMEOUT.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_DEEP_LINK_FLOW_STARTED.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_DEEP_LINK_FLOW_SUCCESS.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_DEEP_LINK_FLOW_ABANDONED.pixelName to PixelParameter.removeAtb(),
+
+            SyncPixelName.SYNC_SETUP_BARCODE_SCREEN_SHOWN.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_BARCODE_SCANNER_SUCCESS.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_BARCODE_SCANNER_FAILED.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_BARCODE_CODE_COPIED.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_MANUAL_CODE_ENTRY_SCREEN_SHOWN.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_MANUAL_CODE_ENTERED_FAILED.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_MANUAL_CODE_ENTERED_SUCCESS.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_ENDED_ABANDONED.pixelName to PixelParameter.removeAtb(),
+            SyncPixelName.SYNC_SETUP_ENDED_SUCCESS.pixelName to PixelParameter.removeAtb(),
         )
     }
 }

sync/sync-impl/src/main/java/com/duckduckgo/sync/impl/pixels/SyncPixels.kt

@@ -27,6 +27,8 @@ import com.duckduckgo.sync.impl.pixels.SyncPixelName.SYNC_DAILY
 import com.duckduckgo.sync.impl.pixels.SyncPixelName.SYNC_DAILY_SUCCESS_RATE_PIXEL
 import com.duckduckgo.sync.impl.pixels.SyncPixelName.SYNC_OBJECT_LIMIT_EXCEEDED_DAILY
 import com.duckduckgo.sync.impl.pixels.SyncPixelParameters.SYNC_FEATURE_PROMOTION_SOURCE
+import com.duckduckgo.sync.impl.pixels.SyncPixelParameters.SYNC_SETUP_SCREEN_TYPE
+import com.duckduckgo.sync.impl.pixels.SyncPixels.ScreenType
 import com.duckduckgo.sync.impl.stats.SyncStatsRepository
 import com.duckduckgo.sync.store.SharedPrefsProvider
 import com.squareup.anvil.annotations.ContributesBinding
@@ -88,6 +90,24 @@ interface SyncPixels {
     fun fireUserSwitchedAccount()
     fun fireUserSwitchedLogoutError()
     fun fireUserSwitchedLoginError()
+    fun fireTimeoutOnDeepLinkSetup()
+    fun fireSyncBarcodeScreenShown(screenType: ScreenType)
+    fun fireSyncSetupFinishedSuccessfully(screenType: ScreenType)
+    fun fireSyncSetupAbandoned(screenType: ScreenType)
+    fun fireSyncSetupManualCodeScreenShown(screenType: ScreenType)
+    fun fireSyncSetupCodePastedParseSuccess(screenType: ScreenType)
+    fun fireSyncSetupCodePastedParseFailure(screenType: ScreenType)
+    fun fireSyncSetupCodeCopiedToClipboard(screenType: ScreenType)
+    fun fireBarcodeScannerParseError(screenType: ScreenType)
+    fun fireBarcodeScannerParseSuccess(screenType: ScreenType)
+
+    enum class ScreenType(val value: String) {
+        SYNC_CONNECT("connect"),
+        SYNC_EXCHANGE("exchange"),
+    }
+    fun fireSetupDeepLinkFlowStarted()
+    fun fireSetupDeepLinkFlowSuccess()
+    fun fireSetupDeepLinkFlowAbandoned()
 }
 
 @ContributesBinding(AppScope::class)
@@ -282,10 +302,71 @@ class RealSyncPixels @Inject constructor(
         pixel.fire(SyncPixelName.SYNC_USER_SWITCHED_LOGIN_ERROR)
     }
 
+    override fun fireTimeoutOnDeepLinkSetup() {
+        pixel.fire(SyncPixelName.SYNC_SETUP_DEEP_LINK_TIMEOUT)
+    }
+
     override fun fireUserSwitchedLogoutError() {
         pixel.fire(SyncPixelName.SYNC_USER_SWITCHED_LOGOUT_ERROR)
     }
 
+    override fun fireSetupDeepLinkFlowStarted() {
+        pixel.fire(SyncPixelName.SYNC_SETUP_DEEP_LINK_FLOW_STARTED)
+    }
+
+    override fun fireSetupDeepLinkFlowSuccess() {
+        pixel.fire(SyncPixelName.SYNC_SETUP_DEEP_LINK_FLOW_SUCCESS)
+    }
+
+    override fun fireSetupDeepLinkFlowAbandoned() {
+        pixel.fire(SyncPixelName.SYNC_SETUP_DEEP_LINK_FLOW_ABANDONED)
+    }
+
+    override fun fireSyncBarcodeScreenShown(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_BARCODE_SCREEN_SHOWN, parameters = params)
+    }
+
+    override fun fireSyncSetupAbandoned(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_ENDED_ABANDONED, parameters = params)
+    }
+
+    override fun fireSyncSetupFinishedSuccessfully(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_ENDED_SUCCESS, parameters = params)
+    }
+
+    override fun fireSyncSetupManualCodeScreenShown(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_MANUAL_CODE_ENTRY_SCREEN_SHOWN, parameters = params)
+    }
+
+    override fun fireSyncSetupCodePastedParseSuccess(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_MANUAL_CODE_ENTERED_SUCCESS, parameters = params)
+    }
+
+    override fun fireSyncSetupCodePastedParseFailure(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_MANUAL_CODE_ENTERED_FAILED, parameters = params)
+    }
+
+    override fun fireSyncSetupCodeCopiedToClipboard(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_BARCODE_CODE_COPIED, parameters = params)
+    }
+
+    override fun fireBarcodeScannerParseSuccess(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_BARCODE_SCANNER_SUCCESS, parameters = params)
+    }
+
+    override fun fireBarcodeScannerParseError(screenType: ScreenType) {
+        val params = mapOf(SYNC_SETUP_SCREEN_TYPE to screenType.value)
+        pixel.fire(SyncPixelName.SYNC_SETUP_BARCODE_SCANNER_FAILED, parameters = params)
+    }
+
     companion object {
         private const val SYNC_PIXELS_PREF_FILE = "com.duckduckgo.sync.pixels.v1"
     }
@@ -339,6 +420,20 @@ enum class SyncPixelName(override val pixelName: String) : Pixel.PixelName {
     SYNC_USER_SWITCHED_ACCOUNT("sync_user_switched_account"),
     SYNC_USER_SWITCHED_LOGOUT_ERROR("sync_user_switched_logout_error"),
     SYNC_USER_SWITCHED_LOGIN_ERROR("sync_user_switched_login_error"),
+    SYNC_SETUP_DEEP_LINK_TIMEOUT("sync_setup_deep_link_timeout"),
+    SYNC_SETUP_DEEP_LINK_FLOW_STARTED("sync_setup_deep_link_flow_started"),
+    SYNC_SETUP_DEEP_LINK_FLOW_SUCCESS("sync_setup_deep_link_flow_success"),
+    SYNC_SETUP_DEEP_LINK_FLOW_ABANDONED("sync_setup_deep_link_flow_abandoned"),
+
+    SYNC_SETUP_BARCODE_SCREEN_SHOWN("sync_setup_barcode_screen_shown"),
+    SYNC_SETUP_BARCODE_SCANNER_SUCCESS("sync_setup_barcode_scanner_success"),
+    SYNC_SETUP_BARCODE_SCANNER_FAILED("sync_setup_barcode_scanner_failed"),
+    SYNC_SETUP_BARCODE_CODE_COPIED("sync_setup_barcode_code_copied"),
+    SYNC_SETUP_MANUAL_CODE_ENTRY_SCREEN_SHOWN("sync_setup_manual_code_entry_screen_shown"),
+    SYNC_SETUP_MANUAL_CODE_ENTERED_SUCCESS("sync_setup_manual_code_entered_success"),
+    SYNC_SETUP_MANUAL_CODE_ENTERED_FAILED("sync_setup_manual_code_entered_failed"),
+    SYNC_SETUP_ENDED_ABANDONED("sync_setup_ended_abandoned"),
+    SYNC_SETUP_ENDED_SUCCESS("sync_setup_ended_success"),
 }
 
 object SyncPixelParameters {
@@ -359,4 +454,5 @@ object SyncPixelParameters {
     const val ERROR = "error"
     const val SYNC_FEATURE_PROMOTION_SOURCE = "source"
     const val GET_OTHER_DEVICES_SCREEN_LAUNCH_SOURCE = "source"
+    const val SYNC_SETUP_SCREEN_TYPE = "source"
 }

sync/sync-impl/src/main/java/com/duckduckgo/sync/impl/promotion/SyncGetOnOtherPlatformsActivity.kt

@@ -104,8 +104,14 @@ class SyncGetOnOtherPlatformsActivity : DuckDuckGoActivity() {
     }
 
     private fun extractLaunchSource(): String? {
-        return intent.getActivityParams(SyncGetOnOtherPlatformsParams::class.java)?.source
+        return intent.getActivityParams(SyncGetOnOtherPlatformsParams::class.java)?.source?.value
     }
 }
 
-data class SyncGetOnOtherPlatformsParams(val source: String?) : GlobalActivityStarter.ActivityParams
+data class SyncGetOnOtherPlatformsParams(val source: SyncGetOnOtherPlatformsLaunchSource) : GlobalActivityStarter.ActivityParams
+
+enum class SyncGetOnOtherPlatformsLaunchSource(val value: String) {
+    SOURCE_ACTIVATING("activating"),
+    SOURCE_SYNC_DISABLED("not_activated"),
+    SOURCE_SYNC_ENABLED("activated"),
+}