Deep Link Re-emission Issue on App Background to Foreground Transition - deeplink

[tiagosito]

Describe the bug
When using the Appsflyer SDK (version 6.15.1) with Flutter, the appsflyerSdk.onDeepLinking method is triggered automatically when the app returns to the foreground, causing the deep link to be re-emitted and reprocessed.

To Reproduce
Steps to reproduce the behavior:

1. Integrate Appsflyer SDK version 6.15.1 in a Flutter project.
2. Implement the appsflyerSdk.onDeepLinking method to listen for deep links.
3. Receive and process a deep link while the app is in the foreground.
4. Move the app to the background.
5. Bring the app back to the foreground.
6. Observe that the appsflyerSdk.onDeepLinking method is triggered again.

Expected behavior
The deep link should not be re-emitted and reprocessed when the app returns to the foreground.

• OS: macOS 14.7.2 darwin-arm64
• Android-arm64 • Android 14 (API 34)
• iPhone 16 Pro Max (mobile)

Additional context
I have tried to find a way to clear this information from the SDK but have not been successful. Any assistance or solution to this issue would be greatly appreciated. A suggested solution is to provide a way to clear the deep link information from the SDK after it has been processed by the appsflyerSdk.onDeepLinking method, either by default or through a configuration option in the setup.

[github-actions]

👋 Hi @tiagosito and Thank you for reaching out to us.
In order for us to provide optimal support, please submit a ticket to our support team at support@appsflyer.com.
When submitting the ticket, please specify:

• ✅ your AppsFlyer sign-up (account) email
• ✅ app ID
• ✅ production steps
• ✅ logs
• ✅ code snippets
• ✅ and any additional relevant information.

[tiagosito]

Explanation of Code Changes

Previously, this code was used to process deep links with FirebaseDynamicLink. However, upon adding Appsflyer as the new method for processing deep links, the code caused the deep link to be reprocessed every time the app returned to onResume. Significant changes were necessary to ensure compatibility with both FirebaseDynamicLink and Appsflyer, as both need to be maintained until Firebase is phased out.

Additionally, variable names and code structure have been altered to mask proprietary code, except for variables in double quotes, as these are the specific pieces of information that need to be passed.

Previous Code:

// To prevent re-triggering the last deep link/push when the app returns to onResume
override fun onResume() {

    // Clearing the Extras after they have been sent to Flutter
    if (this.intent.extras != null) {
        // Iterate through the list of all keys within the Intent's extras,
        // removing the contained values
        intent.extras!!.keySet().forEach {
            // Log.d("PUSH_NOTIFICATION $it = ", "REMOVING VALUES FROM INTENT").
            this.intent.removeExtra(it)
        }
    }

    super.onResume()
}

Updated Code:

private var lastLinkTime: Long = 0

override fun onResume() {
    super.onResume()

    intent.extras?.let { extras ->
        val linkTime = extras.getLong("deeplink_timestamp", 0)

        if (linkTime > 0 && linkTime != lastLinkTime) {
            // Update the timestamp
            lastLinkTime = linkTime

            // Remove extras AFTER processing the deeplink
            val keysToRemove = mutableListOf<String>()
            if (extras.containsKey("deeplink_timestamp")) {
                keysToRemove.add("deeplink_timestamp")
            }

            // For example, Firebase and Appsflyer keys like "af_consumed", etc.
            if (extras.containsKey("af_consumed")) {
                keysToRemove.add("af_consumed")
            }

            keysToRemove.forEach { key ->
                intent.removeExtra(key)
            }

        } else if (linkTime > 0 && linkTime == lastLinkTime) {
            // Deeplink already consumed previously, do nothing. Remove extras.
            val keysToRemove = mutableListOf<String>()
            if (extras.containsKey("deeplink_timestamp")) {
                keysToRemove.add("deeplink_timestamp")
            }
            if (extras.containsKey("af_consumed")) {
                keysToRemove.add("af_consumed")
            }

            keysToRemove.forEach { key ->
                intent.removeExtra(key)
            }
        }
    }
}

override fun onNewIntent(newIntent: Intent) {
    super.onNewIntent(newIntent)
    setIntent(newIntent)
    
    // Reset the timestamp for new deeplinks
    lastLinkTime = 0
}

Detailed Explanation

1. Context:

   • Initially, this code was implemented to handle deep links using FirebaseDynamicLink.
   • With the integration of Appsflyer, it became necessary to adjust the code to prevent reprocessing of the deep link when returning to onResume.

2. Problem:

   • Adding Appsflyer caused the existing code to reprocess deep links every time the app returned to the onResume state.
   • This resulted in an undesirable user experience, where the same deep link was processed repeatedly.

3. Solution:

   • The code needed to be modified to support both FirebaseDynamicLink and Appsflyer.
   • The solution involved clearing the extras from the intent after they were sent to Flutter, ensuring they were not processed again.

4. Clearing Extras:

   • The code checks if the intent contains any extras.
   • If extras are present, it iterates through all the keys in the extras bundle.
   • For each key, it removes the associated value from the intent. This effectively clears the extras, ensuring they are not processed again when the app resumes.

This approach ensures that the app handles intents in a clean and predictable manner, avoiding potential issues with reprocessing intent data.