Technical Guide: How to Replace Firebase Dynamic Links with Tapp for iOS & Android

The clock has run out on Firebase Dynamic Links, and it’s time to migrate. This is a hands-on firebase migration guide designed to help you quickly and painlessly replace Firebase Dynamic Links with Tapp. Our goal is to get you from your old FDL implementation to a fully working Tapp deep link implementation in just four straightforward steps.

This firebase dynamic links tutorial is for developers. We’ll skip the marketing fluff and get straight to the code. You’ll see just how simple the FDL migration process can be.

The process is simple:

1. Audit your existing FDL implementation.
2. Install and configure the lightweight Tapp SDK.
3. Implement the handler to receive deep link data.
4. Create your new links and test.

Prerequisites

Before you start writing code, make sure you have the following:

• A Tapp account.
• Your unique Tapp API key from the dashboard.
• Your app’s iOS Bundle ID and/or Android Package Name.

Step 1: The FDL Audit (Finding Your Links)

First, you need to find every place in your codebase that handles the creation or reception of a Firebase Dynamic Link. A simple project-wide search is the most effective way to do this.

Search your iOS project for:

• FirebaseDynamicLinks.dynamicLinks()
• .handleUniversalLink(

Search your Android project for:

• Firebase.dynamicLinks
• .getDynamicLink(

Take note of the parameters you were passing in your old links and where in your app you were routing users. This will be the logic you re-implement in Step 3.

Step 2: Installing & Configuring the Tapp SDK

Our SDK is designed to be lightweight and simple to install.

For iOS (Swift)

We support Swift Package Manager, the modern standard for iOS dependencies.

1. In Xcode, go to File > Add Packages…
2. In the search bar, paste the Tapp SDK repository URL.
3. Choose the Up to Next Major Version rule and click Add Package.

Now, configure the SDK in your AppDelegate.swift. This one-line addition is all you need for setup.

import Tappso

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Your other launch code
        
        Tappso.configure(apiKey: "YOUR_API_KEY")
        
        return true
    }
}

For Android (Kotlin)

We use Gradle for easy dependency management on Android.

1. In your project-level build.gradle file, ensure you have the mavenCentral() repository.
2. In your app-level build.gradle.kts (or build.gradle), add the Tapp SDK dependency:

dependencies {
    // Other dependencies
    implementation("so.tapp:sdk-android:1.0.0") 
}

Note: Check for the latest version number.

Now, configure the SDK in your Application class.

import android.app.Application
import so.tapp.Tappso

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        
        Tappso.configure(this, "YOUR_API_KEY")
    }
}

Step 3: Receiving Deep Link Data

This is the critical step where you replace your old FDL handler. Our SDK makes this incredibly simple. When a user opens your app from a Tapp link, the SDK automatically fetches the deep link data, including any custom parameters you defined.

For iOS (Swift)

In your AppDelegate, add the TappsoDelegate and implement the tappso(didResolve deeplink:) function. This is the direct replacement for the old FDL completion handler.

import Tappso

@main
class AppDelegate: UIResponder, UIApplicationDelegate, TappsoDelegate {
    
    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        Tappso.configure(apiKey: "YOUR_API_KEY")
        Tappso.delegate = self // Set the delegate
        return true
    }

    // This function is called when a deep link is resolved
    func tappso(didResolve deeplink: Tappso.Deeplink) {
        print("Tapp deeplink received!")
        
        // Access your custom parameters
        if let productId = deeplink.params["productId"] as? String {
            print("Routing to product with ID: \(productId)")
            // Your navigation logic here
            // e.g., navigateToProductScreen(with: productId)
        }
        
        // Check if this was the first install
        if deeplink.isFirst {
            print("This was a deferred deep link on a fresh install.")
        }
    }
    
    // You also still need to pass universal links to the SDK
    func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
        if let webpageURL = userActivity.webpageURL {
            Tappso.continueFrom(url: webpageURL)
        }
        return true
    }
}

For Android (Kotlin)

In the Activity that serves as your deep link entry point, you can retrieve the deep link data in the onCreate or onNewIntent method.

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import so.tapp.Tappso

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        handleDeepLink()
    }

    private fun handleDeepLink() {
        Tappso.getDeeplink(intent) { deeplink ->
            deeplink?.let {
                println("Tapp deeplink received!")

                // Access your custom parameters
                val productId = it.params["productId"] as? String
                if (productId != null) {
                    println("Routing to product with ID: $productId")
                    // Your navigation logic here
                    // e.g., navigateToProductScreen(productId)
                }

                // Check if this was the first install
                if (it.isFirst) {
                    println("This was a deferred deep link on a fresh install.")
                }
            }
        }
    }
}

Step 4: Creating Your First Tapp Link

Now that your app is ready to receive links, it’s time to create one. You can easily do this in the Tapp dashboard by plugging in your iOS/Android targets and adding custom key-value pairs for your parameters.

Alternatively, you can create links programmatically with our simple REST API. Here’s a curl example to create a link that points to a specific product page in your app.

curl -X POST 'https://api.tapp.so/v1/links' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data-raw '{
    "ios_target": "your-bundle-id://",
    "android_target": "your-package-name://",
    "params": {
        "productId": "abc-123"
    }
}'

This will return a short link (e.g., https://tapp.so/xYzAbC) that you can use in your marketing campaigns, emails, or anywhere else you previously used an FDL.