urlynk_flutter 1.3.3

A Flutter plugin for deferred deep links and URL shortening, with the option to use your own branded domains.

urlynk_flutter

URLynk (formerly DeepLynks) is a Flutter plugin for deep link and URL shortening, with the option to use your own branded domains. It supports deferred deep links — opening the app directly if installed, or redirecting to the stores for app download, while preserving the original link context through installation.

Features

• Quick Integration: Minimal setup required to get started.
• Platform Support: Supports Android App Links and iOS Universal Links.
• Branded Domain: Use your own branded domain to enhance visibility and user trust.
• Deferred Linking: Seamlessly redirect users to the store for downloads and preserve link even after installation.
• Free Tier: Generous free tier that covers most developers’ needs, including all essential features for deep linking.

Getting Started

1. Visit URLynk
2. Create a free account
3. Register your app to receive a unique App ID
4. Generate an API Key
5. Copy your app's default domain to configure the Android host and the iOS associated domain.
   This will be either the root domain urlynk.in or a subdomain in the format {x}.urlynk.in.

Installation

Add this plugin to your pubspec.yaml:

flutter pub add urlynk_flutter

Platform Setup

Android

Requirements: minSdk >= 21

1. Update AndroidManifest.xml

PATH: android > app > src > main > AndroidManifest.xml

Add Internet permission

<uses-permission android:name="android.permission.INTERNET"/>

Add the following inside your .MainActivity <activity> tag.

<activity android:name=".MainActivity">

    <!-- Add the following lines below: START -->
    <meta-data android:name="flutter_deeplinking_enabled" android:value="true" />
    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />

        <!-- Refer to the [URLynk setup guide](https://app.urlynk.in) to check your app's default domain. -->
        <!-- This will be either the root domain `urlynk.in` or a subdomain in the format `{x}.urlynk.in`. -->
        <!-- If your app is assigned a subdomain, replace the host value below with it. -->
        <!-- Example: android:host="a.urlynk.in" -->
        <data android:scheme="https" android:host="urlynk.in" android:pathPrefix="/<YOUR_APP_ID>/" />

        <!-- Optional branded domain support -->
        <!-- <data android:scheme="https" android:host="your.domain.com" android:pathPrefix="/<YOUR_APP_ID>/" /> -->
    </intent-filter>
    <!-- END -->

</activity>

Note: <YOUR_APP_ID> refers to the App ID generated in your URLynk account. It is not your Android applicationId.

---

iOS

Requirements: iOS >= 12.0 and Swift >= 5.0

1. Allow static pods in your Podfile

PATH: ios > Podfile

target 'Runner' do
  use_frameworks! :linkage => :static  # Update this line
  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
end

2. Update AppDelegate.swift

PATH: ios > Runner > AppDelegate.swift

import Flutter
import UIKit
import URLynk // Add this line

@main
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    GeneratedPluginRegistrant.register(with: self)
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }

  // Add the following method below.
  override func application(
    _ application: UIApplication,
    continue userActivity: NSUserActivity,
    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
  ) -> Bool {
    if userActivity.activityType == NSUserActivityTypeBrowsingWeb, let url = userActivity.webpageURL {
      try? URLynk.shared.handleDeepLink(url: url)
    }
    return true
  }
}

3. Add Associated Domains Capability

1. Open the Runner.xcworkspace in Xcode.

2. Select the top-level Runner project in the Navigator.

3. Go to the Signing & Capabilities tab.

4. Click the + Capability button.

5. Select Associated Domains.

6. In the Associated Domains section, click the + button.

7. Add this domain: applinks:urlynk.in

   NOTE: Refer to the URLynk setup guide to check your app's default domain.
   This will be either the root domain urlynk.in or a subdomain in the format {x}.urlynk.in.
   If your app is assigned a subdomain, replace the associated domain value above with it.
   Example: applinks:a.urlynk.in

8. (Optional) If you're using a branded domain, be sure to add it as well: applinks:your.branded.domain

Usage

1. Configure URLynk Service

This method must be called before using any other methods.

final urlynk = UrlynkFlutter();
await urlynk.configure(appId: '<YOUR_APP_ID>', apiKey: '<YOUR_API_KEY>');

2. Listen for deep link data

_urlynk.onLinkData.listen(
  (res) => log('Received Data: [${res.link}] ${res.data}'),
  onError: (e) => log('Received Data Error: ${e.message}'),
);

NOTE: Deep link handling is only supported on Android and iOS.
On Web, macOS, Windows, and Linux, the onLinkData will have no effect.

3. Create a deep link

try {
  final deepLink = await urlynk.createDeepLink("any data in string format");
  if (deepLink != null) log('Deep link created: $deepLink');
} on PlatformException catch (e) {
  log(e.message ?? '');
}

You can use any stringified data—such as absolute URLs, relative paths, query parameters, or JSON objects — to generate a deep link and retrieve this data when the link is opened.

4. Create short link for a long URL

Note: Short links are for URL shortening only. They do not open the app, redirect to app stores, or capture clicks on app launch like deep links do.

try {
  final shortLink = await urlynk.createShortLink(
    LinkModel(url: 'https://www.google.com/search?q=urlynk'),
  );
  if (shortLink != null) log('Short link created: $shortLink');
} on PlatformException catch (e) {
  log(e.message ?? '');
}

5. Dispose the resources

urlynk.dispose();

Android Testing

Android Deep Link Testing

1. Run the app on an emulator or physical device.
2. Generate a deep link from the app.
3. Execute the following command in your terminal while the app is running:

adb shell am start -a android.intent.action.VIEW -d "GENERATED_DEEP_LINK" YOUR_APPLICATION_ID_[NOT_APP_ID]

If successful:

• The app should launch (if it was in the background).
• onLinkData should receive the payload within a few seconds (depending on network stability).

Android Deferred Link Testing

1. Run the app on a physical device (not reliable on emulator).
2. Generate a deep link from the app.
3. Open the generated link in the device’s browser while the app is running.
4. Ignore the redirect - in production, app will launch if installed, else users will be redirected to the Play Store; in development, this won’t work.
5. Restart the app — onLinkData should receive the payload within a few seconds (depending on network stability).

NOTE: For direct app opening from browser, the app must be published on the Play Store or installed via a Play Store testing track.

Play Store Testing

1. Publish a test build to the Play Console testing track like Internal Testing.
2. Add App Signing key certificate (SHA-256 fingerprint) in the URLynk app settings.
   Path: Play Console → Test and release → App Integrity → Play app signing → Settings → App Signing key certificate → SHA-256 fingerprint
3. Wait at least 5 minutes to allow the Digital Asset Links JSON to propagate.
4. Verify deep link setup in Play Console: Grow users → Deep links
   You should see the status All links working and your intent-filter data listed under App configuration web links.
5. Share and accept the tester opt-in link on the device/account you plan to test with.
6. Uninstall any existing build of the app from this device.
7. Open a generated deep link in the browser - it should redirect to your Play Store listing for the test build.
8. Install the test build from the Play Store.
9. Open the app after installation - onLinkData should receive the payload attached to the original link within a few seconds (depending on network stability).
10. Copy your deep link into a text editor on your device, then tap it directly. This should open the app directly.

NOTE: When testing from the Play Store’s testing track, deep links may sometimes redirect to the Play Store page instead of opening the installed app.
Use text editor method (step 10) for development.
(Rest assured, once your app is live, links will also open directly from the browser.)

---

iOS Testing

NOTE: During development, deep links will not open the app directly. Direct open only works once the app has a live version on the App Store (not just TestFlight) — even if that live version is not configured for universal links (deep links).

1. Run the app on a simulator (not reliable for iPad) or physical device.
2. Generate a deep link from the app.
3. Open the generated link in the device’s browser while the app is running.
4. Ignore the redirect - in production, app will launch if installed, else user will be redirected to the App Store; in development, this won’t work.
5. Restart the app — onLinkData should receive the payload within a few seconds (depending on network stability).

Important

After publishing your app to the Stores, update the App Signing key certificate (SHA-256 key), Team ID, and App Store URL in the URLynk app settings.
This is essential for enabling direct app openings and proper store redirection via deep links.