Firebase Dynamic Links are smart URLs that enable you to send existing and potential users to any location within your iOS or Android app. They survive the app install process, so even new users can see the content they were initially directed to.

• Deep Linking: Direct users to specific content within your app.
• Cross-Platform: Works on iOS, Android, and web.
• Survive App Install: Links retain their context even if the app is not installed.
• Customizable: Create short or long links with custom parameters.

1. Enable Dynamic Links in Firebase Console:

   • Go to the Firebase Console.
   • Select your project.
   • In the left-hand menu, navigate to "Engage" and select "Dynamic Links".
   • Click "Get Started" and follow the prompts to enable Dynamic Links.

2. Add Firebase SDK to Your App:

   • For Android:

     dependencies {
         implementation 'com.google.firebase:firebase-dynamic-links:19.1.0'
     }
     

   • For iOS:

     pod 'Firebase/DynamicLinks'
     

3. Configure Your App:

   • Android: Add the Dynamic Links intent filter to your AndroidManifest.xml:

     <intent-filter>
         <action android:name="android.intent.action.VIEW"/>
         <category android:name="android.intent.category.DEFAULT"/>
         <category android:name="android.intent.category.BROWSABLE"/>
         <data
             android:host="example.page.link"
             android:scheme="https"/>
     </intent-filter>
     

   • iOS: Configure your app to handle Universal Links by adding an applinks entry to your Associated Domains in Xcode.

1. Navigate to the Dynamic Links section in the Firebase Console.
2. Click on "New Dynamic Link".
3. Fill in the required fields:
   • Link Name: A name for your link.
   • Dynamic Link Domain: The domain you set up.
   • Deep Link URL: The URL you want to deep link to.
   • iOS and Android Behavior: Specify how the link should behave on each platform.
4. Click "Create".

• Android:

  FirebaseDynamicLinks.getInstance().createDynamicLink()
      .setLink(Uri.parse("https://www.example.com/"))
      .setDomainUriPrefix("https://example.page.link")
      .setAndroidParameters(new DynamicLink.AndroidParameters.Builder().build())
      .setIosParameters(new DynamicLink.IosParameters.Builder("com.example.ios").build())
      .buildShortDynamicLink()
      .addOnCompleteListener(new OnCompleteListener<ShortDynamicLink>() {
          @Override
          public void onComplete(@NonNull Task<ShortDynamicLink> task) {
              if (task.isSuccessful()) {
                  Uri shortLink = task.getResult().getShortLink();
                  Uri flowchartLink = task.getResult().getPreviewLink();
                  // Use the shortLink
              } else {
                  // Handle error
              }
          }
      });
  

• iOS:

  let link = URL(string: "https://www.example.com/")!
  let dynamicLinksDomainURIPrefix = "https://example.page.link"
  let builder = DynamicLinkComponents(link: link, domainURIPrefix: dynamicLinksDomainURIPrefix)
  builder?.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
  builder?.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")
  
  builder?.shorten { (shortURL, warnings, error) in
      if let error = error {
          print("Error: \\(error.localizedDescription)")
          return
      }
      if let shortURL = shortURL {
          print("The short URL is: \\(shortURL)")
      }
  }
  

• Add the following code to your MainActivity to handle the incoming dynamic link:

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
  
      FirebaseDynamicLinks.getInstance()
          .getDynamicLink(getIntent())
          .addOnSuccessListener(this, new OnSuccessListener<PendingDynamicLinkData>() {
              @Override
              public void onSuccess(PendingDynamicLinkData pendingDynamicLinkData) {
                  Uri deepLink = null;
                  if (pendingDynamicLinkData != null) {
                      deepLink = pendingDynamicLinkData.getLink();
                  }
                  // Handle the deep link
              }
          })
          .addOnFailureListener(this, new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                  Log.w(TAG, "getDynamicLink:onFailure", e);
              }
          });
  }
  

• Add the following code to your AppDelegate to handle the incoming dynamic link:

  func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
      guard let incomingURL = userActivity.webpageURL else {
          return false
      }
  
      let linkHandled = DynamicLinks.dynamicLinks().handleUniversalLink(incomingURL) { (dynamiclink, error) in
          guard error == nil else {
              print("Error: \\(error!.localizedDescription)")
              return
          }
          if let dynamicLink = dynamiclink, let url = dynamicLink.url {
              // Handle the deep link
          }
      }
      return linkHandled
  }
  

Create a Firebase Dynamic Link that directs users to a specific page in your app. Ensure the link works on both Android and iOS platforms.

1. Set up Firebase Dynamic Links in the Firebase Console.
2. Add the necessary dependencies and configurations to your Android and iOS projects.
3. Create a dynamic link programmatically.
4. Handle the dynamic link in your app to navigate to the specified page.

Follow the steps outlined in the "Setting Up Firebase Dynamic Links" and "Creating Dynamic Links" sections above. Ensure you test the link on both platforms to verify it works as expected.

• Incorrect Domain Configuration: Ensure your dynamic link domain is correctly set up in the Firebase Console and matches the domain used in your app configuration.
• Handling Links: Always check for null values when handling incoming dynamic links to avoid crashes.
• Testing: Test your dynamic links thoroughly on both iOS and Android to ensure they work as expected.

Firebase Dynamic Links provide a powerful way to enhance user experience by directing users to specific content within your app, even if the app is not installed. By following the steps outlined in this module, you can set up, create, and handle dynamic links effectively in your Android and iOS applications.