HopLinks Developer Guide

Welcome to the HopLinks Developer Guide. This manual provides comprehensive instructions for integrating HopLinks—our intelligent Dynamic and Deferred Deep Linking engine—directly into your mobile ecosystem without the need for proprietary SDKs.

How Deferred Links Work

Standard deep links fail if the app isn't installed. Deferred Deep Links "remember" the destination during the installation process, ensuring the user lands exactly where they intended after their first launch.

The SDK-Less Philosophy

HopLinks provides a seamless routing experience entirely without a proprietary SDK. Instead of forcing you to bloat your app with third-party libraries, HopLinks leverages the native deep linking protocols built directly into iOS and Android.

1. Dashboard Configuration

Register your application in the HopLinks dashboard to activate your verification endpoints.

2. Native Platform Setup

Configure your native project to recognize the HopLinks domain (www.hpln.in).

Android (App Links)

Add the following intent filter to your AndroidManifest.xml:

<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" />
    <data android:scheme="https" android:host="www.hpln.in" />
</intent-filter>

iOS (Universal Links)

In Xcode, go to Signing & Capabilities and add the Associated Domains capability with:

Note: Use your custom domain if you have one configured in HopLinks.

Integration: React Native (CLI)

In Expo, deep linking is mostly configured in app.json. In React Native CLI, you must modify native files for both Android and iOS. This guide walks through every step needed to replicate Expo deep linking behavior in a bare React Native CLI project.

<intent-filter android:label="Deep Link">
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <data android:scheme="myapp" />
</intent-filter>

<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" />
    <data android:scheme="https" android:host="hoplinks.in" />
    <data android:scheme="https" android:host="www.hpln.in" />
</intent-filter>

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>myapp</string>
        </array>
    </dict>
</array>

#import <React/RCTLinkingManager.h>

- (BOOL)application:(UIApplication *)application
   openURL:(NSURL *)url
   options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options
{
  return [RCTLinkingManager application:application openURL:url options:options];
}

- (BOOL)application:(UIApplication *)application
    continueUserActivity:(nonnull NSUserActivity *)userActivity
    restorationHandler:(nonnull void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler
{
  return [RCTLinkingManager application:application
                   continueUserActivity:userActivity
                     restorationHandler:restorationHandler];
}

const linking = {
  prefixes: [
    "myapp://",           // Custom URI scheme
    "https://hoplinks.in", // Universal link
  ],
  config: {
    screens: {
      Home:          "home",
      Explore:       "product/:id",  // :id is a dynamic parameter
      Notifications: "notifications",
      Profile:       "profile",
    },
  },
};

// Inside your App component:
<NavigationContainer linking={linking}>
  {/* ... Navigator ... */}
</NavigationContainer>

adb shell am start -W \
  -a android.intent.action.VIEW \
  -d "myapp://product/42" \
  com.reactnativeclidemo

xcrun simctl openurl booted "myapp://product/42"

Integration: React Native (Expo) + Hoplinks

Complete Setup for both Android and iOS platforms.

npx expo install expo-linking

{
  "expo": {
    "scheme": "myapp",
    "ios": {
      "bundleIdentifier": "com.example.myapp",
      "associatedDomains": [
        "applinks:www.hpln.in",
        "applinks:hoplinks.in"
      ]
    },
    "android": {
      "package": "com.example.myapp",
      "intentFilters": [
        {
          "action": "VIEW",
          "autoVerify": true,
          "data": [
            { "scheme": "https", "host": "www.hpln.in" },
            { "scheme": "https", "host": "hoplinks.in" }
          ]
        }
      ]
    }
  }
}

import * as Linking from 'expo-linking';
import { NavigationContainer } from '@react-navigation/native';
 
// Step 3.1 — base prefix for Expo Go development URLs
const prefix = Linking.createURL('/');
 
// Step 3.2 — full routing configuration
const linking = {
  prefixes: [
    prefix,              // Expo Go URLs
    'myapp://',          // Custom scheme
    'https://www.hpln.in',
    'https://hoplinks.in',
  ],
  config: {
    screens: {
      Home:          'home',
      Explore:       'product/:id',   // :id is a dynamic param
      Notifications: 'notifications',
      Profile:       'profile',
    },
  },
};
 
// Step 3.3 — pass into NavigationContainer
export default function App() {
  return (
    <NavigationContainer linking={linking}>
      {/* Your Tab.Navigator goes here */}
    </NavigationContainer>
  );
}

import { useRoute } from '@react-navigation/native';
import { View, Text } from 'react-native';
 
export default function ExploreScreen() {
  const route = useRoute();
 
  // Extract the dynamic :id segment from the deep link
  const deepLinkId = route.params?.id;
 
  return (
    <View>
      {deepLinkId && (
        <Text>You opened product: {deepLinkId}</Text>
      )}
    </View>
  );
}

# Run on a connected Android emulator or device
adb shell am start -W -a android.intent.action.VIEW \
  -d "exp://127.0.0.1:8081/--/product/id123"

# Test the custom scheme
npx uri-scheme open "myapp://product/id123" --android
 
# Test a verified App Link
npx uri-scheme open "https://hoplinks.in/product/id123" --android

const linking = {
  prefixes: [prefix, 'myapp://', 'https://www.hpln.in', 'https://hoplinks.in'],
 
  // NEW — catches the URL that launched the app
  async getInitialURL() {
    // 1. Check if opened via a standard OS deep link
    const url = await Linking.getInitialURL();
    if (url != null) return url;
 
    // 2. (Optional) Call Hoplinks SDK for deferred link data
    // const deferredUrl = await Hoplinks.getDeferredLink();
    // if (deferredUrl) return deferredUrl;
 
    return null;
  },
 
  config: {
    screens: {
      Home:          'home',
      Explore:       'product/:id',
      Notifications: 'notifications',
      Profile:       'profile',
    },
  },
};

Integration: Flutter

Add the app_links package to your pubspec.yaml and initialize the listener:

import 'dart:async';
import 'package:app_links/app_links.dart';

class _MyAppState extends State<MyApp> {
  late AppLinks _appLinks;
  StreamSubscription<Uri>? _linkSubscription;

  @override
  void initState() {
    super.initState();
    initDeepLinks();
  }

  Future<void> initDeepLinks() async {
    _appLinks = AppLinks();

    // Handle deep links when app is in background/foreground
    _linkSubscription = _appLinks.uriLinkStream.listen((uri) {
      print('Received HopLink: $uri');
      _handleLinkRoute(uri);
    });

    // Handle deep link when app opens from cold start
    final initialUri = await _appLinks.getInitialAppLink();
    if (initialUri != null) _handleLinkRoute(initialUri);
  }

  void _handleLinkRoute(Uri uri) {
    if (uri.host == 'www.hpln.in') {
        String code = uri.pathSegments.last;
        print("Navigate to: $code");
    }
  }
}

Integration: Android (Kotlin)

In your MainActivity.kt, override onCreate and onNewIntent to catch the URL parameters.

import android.content.Intent
import android.net.Uri
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        handleDeepLink(intent)
    }

    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        handleDeepLink(intent)
    }

    private fun handleDeepLink(intent: Intent?) {
        val action: String? = intent?.action
        val data: Uri? = intent?.data
        if (Intent.ACTION_VIEW == action && data != null) {
            val code = data.lastPathSegment
            println("Received HopLink code: $code")
        }
    }
}

Integration: Android (Java)

Similar to Kotlin, override the intent handling methods in MainActivity.java.

import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        handleDeepLink(getIntent());
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        handleDeepLink(intent);
    }

    private void handleDeepLink(Intent intent) {
        String action = intent.getAction();
        Uri data = intent.getData();
        if (Intent.ACTION_VIEW.equals(action) && data != null) {
            String code = data.getLastPathSegment();
            // Route to appropriate activity
        }
    }
}

Integration: iOS (Swift)

For iOS apps using SceneDelegate.swift (iOS 13+), intercept the NSUserActivity:

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
        if userActivity.activityType == NSUserActivityTypeBrowsingWeb,
           let incomingURL = userActivity.webpageURL {
            handleDeepLink(url: incomingURL)
        }
    }

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession,
               options connectionOptions: UIScene.ConnectionOptions) {
        if let userActivity = connectionOptions.userActivities.first,
           userActivity.activityType == NSUserActivityTypeBrowsingWeb,
           let incomingURL = userActivity.webpageURL {
            handleDeepLink(url: incomingURL)
        }
    }

    private func handleDeepLink(url: URL) {
        let pathComponents = url.pathComponents
        if let code = pathComponents.last {
            print("Navigate to content: \(code)")
        }
    }
}

Troubleshooting