At a glance: Direct deep linking setup enables the marketer to create links that will send existing app users to a specific app experience (e.g. a specific page in the app). Deep link setup is also a prerequisite for deferred deep linking.


Overview
Deep linking directs mobile users into a specific activity or content in an app.
This in-app routing to a specific activity in the app is possible due to the deep_link_value
that is passed to the app when the OS opens the app and the onAppOpenAttribution
method is called. AppsFlyer's OneLink ensures that the correct value is passed along with the user's click, thus personalizing the user’s app experience.
Only the deep_link_value
is required for deep linking. However, other parameters and values (such as custom attribution parameters) can also be added to the link and returned by the SDK as deep linking data.
The marketer and developer must coordinate regarding desired app behavior and deep_link_value
. The marketer uses the parameters to create deep links, and the developer customizes the behavior of the app based on the value received.
The AppsFlyer SDK returns the parameters from the link that the user clicked, and it is the developer's responsibility to make sure the parameters are handled correctly in the app, for both in-app routing, and personalizing data in the link.


- User clicks the OneLink short URL.
- iOS reads the app’s Associated Domains Entitlements.
- iOS opens the app.
- AppsFlyer SDK is triggered inside the app.
- AppsFlyer SDK retrieves the OneLink data.
- In a short URL, the data is retrieved from the short URL resolver API in AppsFlyer's servers.
- In a long URL, the data is retrieved directly from the long URL.
- AppsFlyer SDK triggers
onAppOpenAttribution()
with the retrieved parameters and cached attribution parameters (e.g.install_time
). - Asynchronously,
onConversionDataSuccess()
is called, holding the full cached attribution data. (You can exit this function by checking ifis_first_launch
istrue
.) onAppOpenAttribution()
uses theattributionData
map to dispatch other activities in the app and pass relevant data.- This creates the personalized experience for the user, which is the main goal of OneLink.
Procedures
To implement the onAppOpenAttribution method and set up the parameter behaviors, the following action checklist of procedures need to be completed.
Procedure checklist |
---|
|
|
|
|
Deciding app behavior
To decide what the app behavior is when the link is clicked:
Get from the marketer: The expected behavior of the link when it is clicked.
Planning method input
When a OneLink is clicked and the user has the app installed on their device, the onAppOpenAttribution
method is called by the AppsFlyer SDK. This is referred to as a retargeting re-engagement.
The onAppOpenAttribution
method gets variables as an input like this:
attributionData: [AnyHashable: Any]
The input data structure is described here.
The marketer and developers need to plan the deep_link_value
(and possible other parameters and values) together based on the desired app behavior when the link is clicked.
To plan the deep_link_value
, and other parameter names and values based on the expected link behavior:
- Tell the marketer what parameters and values are needed in order to implement the desired app behavior.
- Decide on naming conventions for the
deep_link_value
and other parameters and values.
Note: Custom parameters will not appear in raw data collected in AppsFlyer.
Tip
The marketer and developers need to decide together on the best long term system for the
deep_link_value
(and any other parameters/values) to minimize additional app updates.The
deep_link_value
can be based on a SKU, post ID, path, or anything else. We strongly recommend agreeing with your developers on a system that allows for you to enter dynamic values on your chosen parameter, so you can generate many different deep links that go to different content within the app, without any further changes to the app code by the developers.See the following URL examples. The
deep_link_value
of a fruit type was chosen by the marketer and developer together. And the developers made the values dynamic, so the marketer could enter any fruit without the need for further work by the dev team.https://onelink-sample-app.onelink.me/H5hv?pid=Email&c=fruit_of_the_month**&deep_link_value=apples**...
https://onelink-sample-app.onelink.me/H5hv?pid=Email&c=fruit_of_the_month**&deep_link_value=bananas**...
https://onelink-sample-app.onelink.me/H5hv?pid=Email&c=fruit_of_the_month**&deep_link_value=peaches**...
Implementing onAppOpenAttribution() logic
The deep link opens the onAppOpenAttribution
method in the AppDelegate. The deep_link_value
and other parameters in the method input are used to implement the specific user experience when the application is opened.
To implement the logic:
- Implement the logic based on the chosen parameters and values. See the following code example.
- Once completed, send confirmation to the marketer that the app behaves accordingly.
Sample code
func onAppOpenAttribution(_ attributionData: [AnyHashable: Any]) {
//Handle Deep Link Data
print("onAppOpenAttribution data:")
for (key, value) in attributionData {
print(key, ":",value)
}
walkToSceneWithParams(params: attributionData)
}
// User logic
fileprivate func walkToSceneWithParams(params: [AnyHashable:Any]) {
let storyBoard: UIStoryboard = UIStoryboard(name: "Main", bundle: nil)
UIApplication.shared.windows.first?.rootViewController?.dismiss(animated: true, completion: nil)
var fruitNameStr = ""
if let thisFruitName = params["deep_link_value"] as? String {
fruitNameStr = thisFruitName
} else if let linkParam = params["link"] as? String {
guard let url = URLComponents(string: linkParam) else {
print("Could not extract query params from link")
return
}
if let thisFruitName = url.queryItems?.first(where: { $0.name == "deep_link_value" })?.value {
fruitNameStr = thisFruitName
}
}
let destVC = fruitNameStr + "_vc"
if let newVC = storyBoard.instantiateVC(withIdentifier: destVC) {
print("AppsFlyer routing to section: \(destVC)")
newVC.attributionData = params
UIApplication.shared.windows.first?.rootViewController?.present(newVC, animated: true, completion: nil)
} else {
print("AppsFlyer: could not find section: \(destVC)")
}
}
⇲ Github links: Swift
Implementing onAppOpenAttributionFailure() logic
The onAttributionFailure
method is called whenever the call to onAppOpenAttribution
fails. The function should report the error and create an expected experience for the user.
To implement the onAppOpenAttributionFailure method:
Enter the following code:
func onAppOpenAttributionFailure(_ error: Error) {
print("\(error)")
}
⇲ Github links: [Swift][oafailure_swift]
Updated 4 months ago