Repository files navigation

This is the React Native SDK of Adjust™. You can read more about Adjust™ atadjust.com.

• Supported versions
• Example app
• Basic integration
  • Get the SDK
  • Add the AdSupport and iAd framework
  • Integrate the SDK into your app
  • Adjust logging
  • Adjust project settings
    • Android permissions
    • Google Play Services
    • Proguard settings
    • Android install referrer
• Additional features
  • Event tracking
    • Revenue tracking
    • Revenue deduplication
    • In-app purchase verification
    • Callback parameters
    • Partner parameters
  • Session parameters
    • Session callback parameters
    • Session partner parameters
    • Delay start
  • Attribution callback
  • Session and event callbacks
  • Disable tracking
  • Offline mode
  • Event buffering
  • Background tracking
  • Device IDs
    • iOS advertising identifier
    • Google Play Services advertising identifier
    • Adjust device identifier
  • Push token
  • Pre-installed trackers
  • Deep linking
    • Standard deep linking
    • Deferred deep linking
    • Reattribution via deep links
• License

There is an example app inside theexample directory.

We will describe the steps to integrate the Adjust SDK into your React Native project. You can use any text editor or IDE for React Native development. There are no assumptions made regarding development environment.

First, download the library fromnpm:

$ npm install react-native-adjust --save

Then you must install the native dependencies. You can usereact-native cli tool to add native dependencies automatically and then continue the directions below depending on your target OS.

$ react-native link

ForiOS, you don't need to do anything else.

ForAndroid, youmay need to check if Adjust package was added to the native module's package list.

• Go to your app'sMainApplication.java class. It should be located in./android/app/src/main/java/[your app]/MainApplication.java

• There is a method calledgetPackages() that looks like this by default:

@OverrideprotectedList<ReactPackage>getPackages() {returnArrays.<ReactPackage>asList(newMainReactPackage()  );}

• After adding Adjust SDK vianpm and runningreact-native link command, Adjust package should be added automatically to this list and it should look something like this:

importcom.adjust.nativemodule.AdjustPackage;// ...@OverrideprotectedList<ReactPackage>getPackages() {returnArrays.<ReactPackage>asList(newMainReactPackage(),newAdjustPackage()  );}

• In case that the linenew AdjustPackage() was not added automatically, you'll have to add it to the list of packages by yourself like described above. Also, don't forget to add the import statement on top of theMainApplication.java file:

import com.adjust.nativemodule.AdjustPackage;

Select your project in the Project Navigator. In the left hand side of the main view, select your target. In the tabBuild Phases, expand the groupLink Binary with Libraries. On the bottom of that section click on the+ button. Select theAdSupport.framework and click theAdd button. Unless you are using tvOS, repeat the same steps to add theiAd.framework. Change theStatus of both frameworks toOptional.

You should use the following import statement on top of your.js file

import{Adjust,AdjustEvent,AdjustConfig}from'react-native-adjust';

In yourindex.android.js orindex.ios.js file, add the following code to initialize the Adjust SDK:

componentWillMount(){varadjustConfig=newAdjustConfig("{YourAppToken}",AdjustConfig.EnvironmentSandbox);Adjust.create(adjustConfig);}

Replace{YourAppToken} with your app token. You can find this in your Adjust dashboard.

Depending on whether you build your app for testing or for production, you must set the environment with one of these values:

AdjustConfig.EnvironmentSandboxAdjustConfig.EnvironmentProduction

Important: This value should be set toAdjustConfig.EnvironmentSandbox if and only if you or someone else is testing your app. Make sure to set the environment toAdjustConfig.EnvironmentProduction just before you publish the app. Set it back toAdjustConfig.EnvironmentSandbox when you start developing and testing it again.

We use this environment to distinguish between real traffic and test traffic from test devices. It is very important that you keep this value meaningful at all times!

You can increase or decrease the amount of logs you see in tests by callingsetLogLevel on yourAdjustConfig instance with one of the following parameters:

adjustConfig.setLogLevel(AdjustConfig.LogLevelVerbose);// enable all loggingadjustConfig.setLogLevel(AdjustConfig.LogLevelDebug);// enable more loggingadjustConfig.setLogLevel(AdjustConfig.LogLevelInfo);// the defaultadjustConfig.setLogLevel(AdjustConfig.LogLevelWarn);// disable info loggingadjustConfig.setLogLevel(AdjustConfig.LogLevelError);// disable warnings as welladjustConfig.setLogLevel(AdjustConfig.LogLevelAssert);// disable errors as welladjustConfig.setLogLevel(AdjustConfig.LogLevelSuppress);// disable all logging

Once the Adjust SDK has been added to your app, certain tweaks are going to be performed so that the Adjust SDK can work properly. Below you can find a description of every additional thing that the Adjust SDK performs after you've added it to your app and what needs to be done by you in order for Adjust SDK to work properly.

The Adjust SDK by default adds two permissions to your app'sAndroidManifest.xml file:

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

TheINTERNET permission might be needed by our SDK at any point in time. TheACCESS_WIFI_STATE permission is needed by the Adjust SDK if your app is not targeting the Google Play Store and doesn't use Google Play Services. If you are targeting the Google Play Store and you are using Google Play Services, the Adjust SDK doesn't need this permission and, if you don't need it anywhere else in your app, you can remove it.

Since August 1, 2014, apps in the Google Play Store must use theGoogle Advertising ID to uniquely identify devices. To allow the Adjust SDK to use the Google Advertising ID, you must integrateGoogle Play Services.

In order to do this, open your app'sbuild.gradle file and find thedependencies block. Add the following line:

```compile 'com.google.android.gms:play-services-analytics:10.0.1'```

Note: The version of the Google Play Services library that you're using is not relevant to the Adjust SDK, as long as the analytics part of the library is present in your app. In the example above, we just used the most recent version of the library at the time of writing.

If you are using Proguard, add these lines to your Proguard file:

-keep public class com.adjust.sdk.** { *; }-keep class com.google.android.gms.common.ConnectionResult {    int SUCCESS;}-keep class com.google.android.gms.ads.identifier.AdvertisingIdClient {    com.google.android.gms.ads.identifier.AdvertisingIdClient$Info getAdvertisingIdInfo(android.content.Context);}-keep class com.google.android.gms.ads.identifier.AdvertisingIdClient$Info {    java.lang.String getId();    boolean isLimitAdTrackingEnabled();}-keep class dalvik.system.VMRuntime {    java.lang.String getRuntime();}-keep class android.os.Build {    java.lang.String[] SUPPORTED_ABIS;    java.lang.String CPU_ABI;}-keep class android.content.res.Configuration {    android.os.LocaledList getLocales();    java.util.Locale locale;}-keep class android.os.LocaledList {    java.util.Locale get(int);}

The Adjust install referrer broadcast receiver is added to your app by default. For more information, you can check our nativeAndroid SDK README. You can see this in theAndroidManifest.xml file which is part of our React Native plugin:

<receiverandroid:name="com.adjust.sdk.AdjustReferrerReceiver"android:exported="true" >    <intent-filter>        <actionandroid:name="com.android.vending.INSTALL_REFERRER" />    </intent-filter></receiver>

Please bear in mind that, if you are using your own broadcast receiver which handles theINSTALL_REFERRER intent, you don't need to add the Adjust broadcast receiver to your manifest file. You can remove it, but inside your own receiver add the call to the Adjust broadcast receiver as described in ourAndroid guide.

You can take advantage of the following features once the Adjust SDK is integrated into your project.

You can use Adjust to track all kinds of events. Let's say you want to track every tap on a button. Simply create a new event token in yourdashboard. Let's say that event token isabc123. You can add the following line in your button’s click handler method to track the click:

varadjustEvent=newAdjustEvent("abc123");Adjust.trackEvent(adjustEvent);

If your users can generate revenue by tapping on advertisements or making In-App Purchases, then you can track those revenues with events. Let's say a tap is worth €0.01. You could track the revenue event like this:

varadjustEvent=newAdjustEvent("abc123");adjustEvent.setRevenue(0.01,"EUR");Adjust.trackEvent(adjustEvent);

When you set a currency token, Adjust will automatically convert the incoming revenues into a reporting revenue of your choice. Read more aboutcurrency conversion here.

You can also add an optional transaction ID to avoid tracking duplicate revenues. The last ten transaction IDs are remembered, and revenue events with duplicate transaction IDs are skipped. This is especially useful for In-App Purchase tracking. You can see an example below.

If you want to track in-app purchases, please make sure to call thetrackEvent only if the transaction is finished and an item is purchased. That way you can avoid tracking revenue that is not actually being generated.

varadjustEvent=newAdjustEvent("abc123");adjustEvent.setRevenue(0.01,"EUR");adjustEvent.setTransactionId("{YourTransactionId}");Adjust.trackEvent(adjustEvent);

Note: Transaction ID is the iOS term, unique identifier for successfully finished Android In-App-Purchases is namedOrder ID.

In-app purchase verification can be conducted through the React Native Purchase SDK which is currently in development and will soon be made publicly available. For more information, please contactsupport@adjust.com.

You can also register a callback URL for that event in yourdashboard and we will send a GET request to that URL whenever the event gets tracked. In that case you can also put some key-value pairs in an object and pass it to thetrackEvent method. We will then append these named parameters to your callback URL.

For example, suppose you have registered the URLhttp://www.adjust.com/callback for your event with event tokenabc123 and execute the following lines:

varadjustEvent=newAdjustEvent("abc123");adjustEvent.addCallbackParameter("key","value");adjustEvent.addCallbackParameter("foo","bar");Adjust.trackEvent(adjustEvent);

In that case we would track the event and send a request to:

http://www.adjust.com/callback?key=value&foo=bar

It should be mentioned that we support a variety of placeholders like{idfa} for iOS or{gps_adid} for Android that can be used as parameter values. In the resulting callback the{idfa} placeholder would be replaced with the ID for Advertisers of the current device for iOS and the{gps_adid} would be replaced with the Google Advertising ID of the current device for Android. Also note that we don't store any of your custom parameters, but only append them to your callbacks. If you haven't registered a callback for an event, these parameters won't even be read.

You can read more about using URL callbacks, including a full list of available values, in ourcallbacks guide.

Similarly to the callback parameters mentioned above, you can also add parameters that Adjust will transmit to the network partners of your choice. You can activate these networks in your Adjust dashboard.

This works similarly to the callback parameters mentioned above, but can be added by calling theaddPartnerParameter method on yourAdjustEvent instance.

varadjustEvent=newAdjustEvent("abc123");adjustEvent.addPartnerParameter("key","value");adjustEvent.addPartnerParameter("foo","bar");Adjust.trackEvent(adjustEvent);

You can read more about special partners and networks in ourguide to special partners.

Some parameters are saved to be sent in every event and session of the Adjust SDK. Once you have added any of these parameters, you don't need to add them every time, since they will be saved locally. If you add the same parameter twice, there will be no effect.

These session parameters can be called before the Adjust SDK is launched to make sure they are sent even on install. If you need to send them with an install, but can only obtain the needed values after launch, it's possible todelay the first launch of the Adjust SDK to allow this behaviour.

The same callback parameters that are registered forevents can be also saved to be sent in every event or session of the Adjust SDK.

The session callback parameters have a similar interface of the event callback parameters. Instead of adding the key and its value to an event, it's added through a call to methodaddSessionCallbackParameter of theAdjust instance:

Adjust.addSessionCallbackParameter("foo","bar");

The session callback parameters will be merged with the callback parameters and added to an event. The callback parameters added to an event have precedence over the session callback parameters. Meaning that, when adding a callback parameter to an event with the same key to one added from the session, the value that prevails is the callback parameter added to the event.

It's possible to remove a specific session callback parameter by passing the desiring key to the methodremoveSessionCallbackParameter of theAdjust instance:

Adjust.removeSessionCallbackParameter("foo");

If you wish to remove all key and values from the session callback parameters, you can reset it with the methodresetSessionCallbackParameters of theAdjust instance:

Adjust.resetSessionCallbackParameters();

In the same way that there aresession callback parameters that are sent for every event or session of the Adjust SDK, there are also session partner parameters.

These will be transmitted to network partners, for the integrations that have been activated in your Adjustdashboard.

The session partner parameters have a similar interface to the event partner parameters. Instead of adding the key and its value to an event, it's added through a call to methodaddSessionPartnerParameter of theAdjust instance:

Adjust.addSessionPartnerParameter("foo","bar");

The session partner parameters will be merged with the partner parameters and added to an event. The partner parameters added to an event have precedence over the session partner parameters. Meaning that, when adding a partner parameter to an event with the same key to one added from the session, the value that prevails is the partner parameter added to the event.

It's possible to remove a specific session partner parameter by passing the desiring key to the methodremoveSessionPartnerParameter of theAdjust instance:

Adjust.removeSessionPartnerParameter("foo");

If you wish to remove all keys and values from the session partner parameters, you can reset it with the methodresetSessionPartnerParameters of theAdjust instance:

Adjust.resetSessionPartnerParameters();

Delaying the start of the Adjust SDK allows your app some time to obtain session parameters, such as unique identifiers, to be sent on install.

Set the initial delay time in seconds with thesetDelayStart field of theAdjustConfig instance:

adjustConfig.setDelayStart(5.5);

In this case this will make the Adjust SDK not send the initial install session and any event created for 5.5 seconds. After this time is expired or if you callsendFirstPackages() of theAdjust instance in the meanwhile, every session parameter will be added to the delayed install session and events and the Adjust SDK will resume as usual.

The maximum delay start time of the Adjust SDK is 10 seconds.

You can register a listener to be notified of tracker attribution changes. Due to the different sources considered for attribution, this information cannot be provided synchronously. The simplest way is to create a single anonymous listener which is going to be calledeach time your user's attribution value changes:

With theAdjustConfig instance, before starting the SDK, add the anonymous listener:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setAttributionCallbackListener(function(attribution){// Printing all attribution properties.console.log("Attribution changed!");console.log(attribution.trackerToken);console.log(attribution.trackerName);console.log(attribution.network);console.log(attribution.campaign);console.log(attribution.adgroup);console.log(attribution.creative);console.log(attribution.clickLabel);console.log(attribution.adid);});Adjust.create(adjustConfig);

Within the listener function you have access to theattribution parameters. Here is a quick summary of its properties:

• trackerToken the tracker token of the current install.
• trackerName the tracker name of the current install.
• network the network grouping level of the current install.
• campaign the campaign grouping level of the current install.
• adgroup the ad group grouping level of the current install.
• creative the creative grouping level of the current install.
• clickLabel the click label of the current install.
• adid the Adjust device identifier.

Please make sure to consider ourapplicable attribution data policies.

You can register a callback to be notified of successful and failed tracked events and/or sessions.

Follow the same steps as for attribution callback to implement the following callback function for successfully tracked events:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setEventTrackingSucceededCallbackListener(function(eventSuccess){// Printing all event success properties.console.log("Event tracking succeeded!");console.log(eventSuccess.message);console.log(eventSuccess.timestamp);console.log(eventSuccess.eventToken);console.log(eventSuccess.adid);console.log(eventSuccess.jsonResponse);});Adjust.create(adjustConfig);

The following callback function for failed tracked events:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setEventTrackingFailedCallbackListener(function(eventFailure){// Printing all event failure properties.console.log("Event tracking failed!");console.log(eventSuccess.message);console.log(eventSuccess.timestamp);console.log(eventSuccess.eventToken);console.log(eventSuccess.adid);console.log(eventSuccess.willRetry);console.log(eventSuccess.jsonResponse);});Adjust.create(adjustConfig);

For successfully tracked sessions:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setSessionTrackingSucceededCallbackListener(function(sessionSuccess){// Printing all session success properties.console.log("Session tracking succeeded!");console.log(sessionSuccess.message);console.log(sessionSuccess.timestamp);console.log(sessionSuccess.adid);console.log(sessionSuccess.jsonResponse);});Adjust.create(adjustConfig);

And for failed tracked sessions:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setSessionTrackingFailedCallbackListener(function(sessionFailure){// Printing all session failure properties.console.log("Session tracking failed!");console.log(sessionSuccess.message);console.log(sessionSuccess.timestamp);console.log(sessionSuccess.adid);console.log(sessionSuccess.willRetry);console.log(sessionSuccess.jsonResponse);});Adjust.create(adjustConfig);

The callback functions will be called after the SDK tries to send a package to the server. Within the callback you have access to a response data object specifically for the callback. Here is a quick summary of the session response data properties:

• var message the message from the server or the error logged by the SDK.
• var timestamp timestamp from the server.
• var adid a unique device identifier provided by Adjust.
• var jsonResponse the JSON object with the response from the server.

Both event response data objects contain:

• var eventToken the event token, if the package tracked was an event.

And both event and session failed objects also contain:

• var willRetry indicates there will be an attempt to resend the package at a later time.

You can disable the Adjust SDK from tracking by invoking the methodsetEnabled of theAdjust instance with the enabled parameter asfalse. This setting isremembered between sessions, but it can only be activated after the first session.

Adjust.setEnabled(false);

You can verify if the Adjust SDK is currently active with the methodisEnabled of theAdjust instance. It is always possible to activate the Adjust SDK by invokingsetEnabled with the parameter set totrue.

You can put the Adjust SDK in offline mode to suspend transmission to our servers while retaining tracked data to be sent later. When in offline mode, all information is saved in a file, so be careful not to trigger too many events while in offline mode.

You can activate offline mode by calling the methodsetOfflineMode of theAdjust instance with the parametertrue.

Adjust.setOfflineMode(true);

Conversely, you can deactivate offline mode by callingsetOfflineMode withfalse. When the Adjust SDK is put back in online mode, all saved information is send to our servers with the correct time information.

Unlike disabling tracking,this setting is not remembered between sessions. This means that the SDK is in online mode whenever it is started, even if the app was terminated in offline mode.

If your app makes heavy use of event tracking, you might want to delay some HTTP requests in order to send them in one batch every minute. You can enable event buffering with yourAdjustConfig instance by callingsetEventBufferingEnabled method:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setEventBufferingEnabled(true);Adjust.create(adjustConfig);

The default behaviour of the Adjust SDK is topause sending HTTP requests while the app is in the background. You can change this in yourAdjustConfig instance by callingsetSendInBackground method:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setSendInBackground(true);Adjust.create(adjustConfig);

If nothing is set, sending in background isdisabled by default.

Certain services (such as Google Analytics) require you to coordinate device and client IDs in order to prevent duplicate reporting.

You can access the IDFA value of an iOS device by invoking thegetIdfa method of theAdjust instance and passing it a callback that will get triggered once the IDFA value has been obtained by the native iOS SDK:

Adjust.getIdfa((idfa)=>{console.log("IDFA = "+idfa);});

The Adjust SDK allows you to read the Google advertising identifier of the Android device on which your app is running. In order to do this, call thegetGoogleAdId method of theAdjust instance and pass your callback as a parameter. Once obtained by the native Android SDK, you will receive the Google advertising identifier value in your callback method:

Adjust.getGoogleAdId((googleAdId)=>{console.log("Google Ad Id = "+googleAdId);});

For every device with your app installed on it, the Adjust backend generates a uniqueAdjust device identifier (adid). In order to obtain this identifier, call thegetAdid method of theAdjust instance and pass your callback as a parameter to which theadid value will be sent once obtained:

Adjust.getAdid((adid)=>{console.log("Adid = "+adid);});

Note: Information about theadid is only available after an app installation has been tracked by the Adjust backend. From that moment on, the Adjust SDK has information about the deviceadid and you can access it with this method. So,it is not possible to access theadid value before the SDK has been initialized and installation of your app has been successfully tracked.

This callback is triggered as described in theattribution callback section, providing you with information about a new attribution whenever it changes. If you want to access information about a user's current attribution status at any other time, you can make a call to thegetAttribution method of theAdjust instance and pass your callback as a parameter to which the attribution value will be sent once obtained:

Adjust.getAttribution((attribution)=>{console.log("Tracker token = "+attribution.trackerToken);console.log("Tracker name = "+attribution.trackerName);console.log("Network = "+attribution.network);console.log("Campaign = "+attribution.campaign);console.log("Adgroup = "+attribution.adgroup);console.log("Creative = "+attribution.creative);console.log("Click label = "+attribution.clickLabel);console.log("Adid = "+attribution.adid);});

Note: Information about a user's current attribution status is only available after an app installation has been tracked by the Adjust backend and the attribution callback has been triggered. From that moment on, the Adjust SDK has information about a user's attribution status and you can access it with this method. So,it is not possible to access a user's attribution value before the SDK has been initialized and an attribution callback has been triggered.

To send us the push notification token, add the following call to Adjustwhenever you get your token in the app or when it gets updated:

Adjust.setPushToken("YourPushNotificationToken");

If you want to use the Adjust SDK to recognize users that found your app pre-installed on their device, follow these steps.

1. Create a new tracker in yourdashboard.

2. Open your app delegate and add set the default tracker of yourAdjustConfig instance:

   varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setDefaultTracker("{TrackerToken}");Adjust.create(adjustConfig);

Replace{TrackerToken} with the tracker token you created in step 2. Please note that the dashboard displays a trackerURL (includinghttp://app.adjust.com/). In your source code, you should specify only the six-character token and not theentire URL.

3. Build and run your app. You should see a line like the following in the app's log output:

   Default tracker: 'abc123'

If you are using the Adjust tracker URL with an option to deep link into your app from the URL, there is the possibility to get info about the deep link URL and its content. Hitting the URL can happen when the user has your app already installed (standard deep linking scenario) or if they don't have the app on their device (deferred deep linking scenario).

To support deep linking in Android, the app'sAndroidManifest.xml file will need to be modified. Please refer to thispage of our Android SDK for the needed modifications toAndroidManifest.xml.

To support deep linking in iOS 8 or earlier, the app'sInfo.plist file will need to be modified. Please refer to thispage of our iOS SDK for the needed modifications toInfo.plist.

To support deep linking in iOS 9 or later, your app would have to handle Universal Links. Please refer to thispage of our iOS SDK for the needed modifications.

After that, refer to this page of theReact Native offical docs for instructions on how to support both platforms and obtain deep link URL in your JavaScript code.

While deferred deep linking is not supported out of the box on Android and iOS, our Adjust SDK makes it possible.

In order to get info about the URL content in a deferred deep linking scenario, you should set a callback method on theAdjustConfig object which will receive one parameter where the content of the URL will be delivered. You should set this method on the config object by calling the methodsetDeeplinkCallbackListener:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setDeferredDeeplinkCallbackListener(function(deeplink){console.log("Deferred deep link URL content: "+deeplink);});Adjust.create(adjustConfig);

In the deferred deep linking scenario, there is one additional setting which can be set on theAdjustConfig object. Once the Adjust SDK gets the deferred deep link info, we are offering you the possibility to choose whether our SDK should open this URL or not. You can choose to set this option by calling thesetShouldLaunchDeeplink method on the config object:

varadjustConfig=newAdjustConfig(appToken,environment);adjustConfig.setShouldLaunchDeeplink(true);// or adjustConfig.setShouldLaunchDeeplink(false);adjustConfig.setDeeplinkCallbackListener(function(deeplink){console.log("Deferred deep link URL content: "+deeplink);});Adjust.create(adjustConfig);

If nothing is set,the Adjust SDK will always try to launch the URL by default.

Adjust enables you to run re-engagement campaigns by using deep links. For more information on this, please check ourofficial docs.

If you are using this feature, in order for your user to be properly reattributed, you need to make one additional call to the Adjust SDK in your app. Once you have received deep link content information in your app, add a call toappWillOpenUrl method of theAdjust instance. By making this call, the Adjust SDK will try to find if there is any new attribution info inside of the deep link and if any, it will be sent to the Adjust backend. If your user should be reattributed due to a click on the Adjust tracker URL with deep link content in it, you will see theattribution callback in your app being triggered with new attribution info for this user.

Call to theappWillOpenUrl method in a React component would look like this:

componentDidMount(){Linking.addEventListener('url',this.handleDeepLink);Linking.getInitialURL().then((url)=>{if(url){this.handleDeepLink({ url});}})}componentWillUnmount(){Linking.removeEventListener('url',this.handleDeepLink);}handleDeepLink(event){Adjust.appWillOpenUrl(event.url);}

The Adjust SDK is licensed under the MIT License.

Copyright (c) 2012-2017 Adjust GmbH,http://www.adjust.com

Permission is hereby granted, free of charge, to any person obtaining a copy ofthis software and associated documentation files (the "Software"), to deal inthe Software without restriction, including without limitation the rights touse, copy, modify, merge, publish, distribute, sublicense, and/or sell copiesof the Software, and to permit persons to whom the Software is furnished to doso, subject to the following conditions:

The above copyright notice and this permission notice shall be included in allcopies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THEAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHERLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THESOFTWARE.