trackLink

Use the below function to pass deeplink URLs to emit tracking data.

Pass all deeplink URL in their final form including all URL parameters. If this is a shortened URL (e.g. URL) - please resolve/convert to the final URL before passing.

Wunderkind.shared.trackLink(URL linkUrl)

Wunderkind.getInstance().trackLink(URL linkUrl)

Wunderkind().trackLink(URL linkUrl)

Wunderkind.trackLink(URL linkUrl)

Example Implementation

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        handleIntent(intent)
    }
    
    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        handleIntent(intent)
    }
    
    private fun handleIntent(intent: Intent) {
        val action = intent.action
        val data = intent.data
        
        if (Intent.ACTION_VIEW == action && data != null) {
            val deeplink = URL(data.toString())
            Wunderkind.getInstance().trackLink(data)
        }
    }
}

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        if let url = ConnectionOptions.URLContexts.first?.url { Wunderkind.shared.trackLink(url) }
        }
    }
    
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url { Wunderkind.shared.trackLink(url) }
        }
    }
}

const DeeplinkHandler = () => {
    useEffect(() => {
        const getUrl = async () => {
            const initialUrl = await Linking.getInitialURL();
            if (initialUrl) {
                const url = new URL(initialUrl);
                Wunderkind.trackLink(url);
            }
        };
        
        getUrl();
        
        const listener = Linking.addEventListener('url', (event) => {
            const url = new URL(event.url);
            Wunderkind.trackLink(url);
        });
        
        return () => {
            listener.remove();
        };
    }, []);
};

export default DeeplinkHandler;

class DeeplinkHandler extends StatefulWidget {
  const DeeplinkHandler({Key? key, required this.child}) : super(key: key);
  
  final Widget child;
  
  @override
  _DeeplinkHandlerState createState() => _DeeplinkHandlerState();
}

class _DeeplinkHandlerState extends State<DeeplinkHandler> {
  StreamSubscription? _streamSubscription;

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

  Future<void> initPlatformState() async {
    try {
      String? initialLink = await getInitialLink();
      if (initialLink != null) {
        Uri url = Uri.parse(initialLink);
        Wunderkind().trackLink(url);
      }
      
      _streamSubscription = linkStream.listen((String? link) {
        if (link != null) {
          Uri url = Uri.parse(link);
          Wunderkind().trackLink(url);
        }
      });
    } catch (e) {
      // Handle exception
    }
  }

  @override
  void dispose() {
    _streamSubscription?.cancel();
    super.dispose();
  }
  
  @override
  Widget build(BuildContext context) {
    return widget.child;
  }
}