class YourApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        try {
            val config = SwrveConfig()
            // To use the EU stack, include this in your config.
            // config.selectedStack = SwrveStack.EU
            SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)
        } catch (exp: IllegalArgumentException) {
            Log.e("SwrveDemo", "Could not initialize the Swrve SDK", exp)
        }
    }
}

public class YourApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        try {
            SwrveConfig config = new SwrveConfig();
            // To use the EU stack, include this in your config.
            // config.setSelectedStack(SwrveStack.EU);
            SwrveSDK.createInstance(this, <app_id>, "<api_key>", config);
        } catch (IllegalArgumentException exp) {
            Log.e("SwrveDemo", "Could not initialize the Swrve SDK", exp);
        }
    }
}

SwrveSDK.createInstance(application, <app_id>, "<api_key>", config);

SwrveSDK.createInstance(application, <app_id>, "<api_key>", config);

SwrveSDK.identify("<external_user_id>", object : SwrveIdentityResponse {
    override fun onSuccess(status: String, swrveId: String) {
        // Success, continue with your logic
    }

    override fun onError(responseCode: Int, errorMessage: String) {
        // Error should be handled.
    }
})

SwrveSDK.identify("<external_user_id>", new SwrveIdentityResponse() {
    @Override
    public void onSuccess(String status, String swrveId) {
        // Success, continue with your logic
    }

    @Override
    public void onError(int responseCode, String errorMessage) {
        // Error should be handled.
    }
});

// In the Application class
    val config = SwrveConfig()
    config.isAutoStartLastUser = false
    SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)

// Later at a certain point in your app - but not in the Application class
    SwrveSDK.identify("<external_user_id>", object : SwrveIdentityResponse {
    override fun onSuccess(status: String, swrveId: String) {
        // Success, continue with your logic
    }

    override fun onError(responseCode: Int, errorMessage: String) {
        // Error should be handled.
    }
})

// In the Application class
    SwrveConfig config = new SwrveConfig();
    config.setAutoStartLastUser(false);
    SwrveSDK.createInstance(this, <app_id>, "<api_key>", config);

// Later at a certain point in your app - but not in the Application class
    SwrveSDK.identify("<external_user_id>", new SwrveIdentityResponse() {
    @Override
    public void onSuccess(String status, String swrveId) {
        // Success, continue with your logic
    }

    @Override
    public void onError(int responseCode, String errorMessage) {
        // Error should be handled.
    }
});

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
                package="${packageName}"
                android:versionCode="1"
                android:versionName="1.0" >
    <!-- Add this to your AndroidManifest.xml -->
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <!-- End of changes -->

    <application android:allowBackup="true"
                 android:icon="@drawable/ic_launcher"
                 android:label="@string/app_name"
                 android:theme="@style/AppTheme" >

        <!-- Add this to your AndroidManifest.xml -->

        <service android:name="com.swrve.sdk.SwrveFirebaseMessagingService">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT" />
            </intent-filter>
        </service>
        <!-- End of changes -->
        ...
    </application>
</manifest>

Step 2: Add the following script dependency:

buildscript {
    // ...
    dependencies {
        // ...
        classpath 'com.google.gms:google-services:4.4.2'
    }
}

Step 3: Add the following plugin to the build.gradle file of your app.

dependencies {
    // ...
   }
// ADD THIS AT THE BOTTOM
apply plugin: 'com.google.gms.google-services'

Step 4: Add the google-services.json from the Firebase Console to your project. For more information, see the Firebase help article, Download a configuration file.

Step 5: Provide your notification configuration to the SwrveConfig and pass into SwrveSDK.createInstance.

val config = SwrveConfig()
val channel: NotificationChannel? = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    NotificationChannel(
        "123",
        "Devapp swrve default channel",
        NotificationManager.IMPORTANCE_DEFAULT
    )
    } else {
        null
    }
val notificationEvents = listOf("tutorial.complete", "subscribe")
val notificationConfig = SwrveNotificationConfig.Builder(R.drawable.logo1, R.drawable.logo2, channel)
    .activityClass(MainActivity::class.java)
    .largeIconDrawableId(R.drawable.swrve_s_solid)
    .accentColorHex("#3949AB")
    .pushNotificationPermissionEvents(notificationEvents)
    .build()
config.notificationConfig = notificationConfig
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          xmlns:amazon="http://schemas.amazon.com/apk/res/android"
          package="${packageName}"
          android:versionCode="1"
          android:versionName="1.0" >
    <!-- Add this to your AndroidManifest.xml -->
    <!-- ADM uses WAKE_LOCK to keep the processor from sleeping when a message is received. -->
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="com.amazon.device.messaging.permission.RECEIVE" />
    <permission android:name="${packageName}.permission.RECEIVE_ADM_MESSAGE"
        android:protectionLevel="signature" />
    <uses-permission android:name="${packageName}.permission.RECEIVE_ADM_MESSAGE" />
    <!-- End of changes -->
    <application android:allowBackup="true"
                 android:icon="@drawable/ic_launcher"
                 android:label="@string/app_name"
                 android:theme="@style/AppTheme" >
        <!-- Add this to your AndroidManifest.xml -->
        <amazon:enable-feature android:name="com.amazon.device.messaging" android:required="true"/>

        <service
            android:name="com.swrve.sdk.SwrveAdmHandlerJobService"
            android:permission="android.permission.BIND_JOB_SERVICE"
            android:exported="false" />

        <service android:name="com.swrve.sdk.SwrveAdmIntentService"
                 android:exported="false" />

        <receiver android:name="com.swrve.sdk.SwrveAdmMessageReceiver"
                  android:permission="com.amazon.device.messaging.permission.SEND" >
            <intent-filter>
                <action android:name="com.amazon.device.messaging.intent.REGISTRATION" />
                <action android:name="com.amazon.device.messaging.intent.RECEIVE" />
                <category android:name="${packageName}" />
            </intent-filter>
        </receiver>
        <!-- End of changes -->
    </application>
</manifest>

Notes:

• For more information, see Amazon Device Messaging.
• Add the the Amazon namespace xmlns:amazon=”http://schemas.amazon.com/apk/res/android to your <manifest>.

Step 2: If you do your own application signing, you need to add the Amazon api_key.txt to the assets folder of your project. To get this key from Amazon, follow this guide on Obtaining Amazon Device Messaging Credentials.

Step 3: Provide your notification configuration to the SwrveConfig and pass into SwrveSDK.createInstance.

val config = SwrveConfig()
var channel: NotificationChannel? = null
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    channel = NotificationChannel(
         "123",
         "Devapp swrve default channel",
          NotificationManager.IMPORTANCE_DEFAULT
    )
    val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
    notificationManager?.createNotificationChannel(channel)
}
val notificationConfig = SwrveNotificationConfig.Builder(R.drawable.logo1, R.drawable.logo2, channel)
    .activityClass(MainActivity::class.java)
    .largeIconDrawableId(R.drawable.swrve_s_solid)
    .accentColorHex("#3949AB")
    .build()
config.notificationConfig = notificationConfig
SwrveSDK.createInstance(this, <app_id>, <api_key>, config)

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          xmlns:amazon="http://schemas.amazon.com/apk/res/android"
          package="${packageName}"
          android:versionCode="1"
          android:versionName="1.0" >
    <application android:allowBackup="true"
                 android:icon="@drawable/ic_launcher"
                 android:label="@string/app_name"
                 android:theme="@style/AppTheme" >
        <!-- Add this to your AndroidManifest.xml -->
        <service android:name="com.swrve.sdk.SwrveHmsMessageService"
                 android:exported="false" >
            <intent-filter>
                <action android:name="com.huawei.push.action.MESSAGING_EVENT" />
            </intent-filter>
        </service>
        <meta-data
            android:name="push_kit_auto_init_enabled"
            android:value="true" />
        <!-- End of changes -->
    </application>
</manifest>

Step 2: Add the following repository to buildscript in the root build.gradle:

buildscript {
    // ...
    repositories {
        // ...
        maven { url 'https://developer.huawei.com/repo/' }
    }
}

Step 3: Add the following dependency to buildscript in the root build.gradle:

buildscript {
    // ...
    dependencies {
        // ...
        classpath 'com.huawei.agconnect:agcp:1.7.2.300'
    }
}

Step 4: Add the following dependency to allprojects in the root build.gradle:

allprojects {
    // ...
    repositories {
        // ...
        maven { url 'https://developer.huawei.com/repo/' }
    }
}

Step 5: Add the following plugin to the build.gradle file of your app:

dependencies {
    // ...
   }
// ADD THIS AT THE BOTTOM
apply plugin: 'com.huawei.agconnect'

Step 6: Add the agconnect-services.json from the Huawei Console to your project. For more information, see the Huawei help article, Download a configuration file.

Step 7: Provide your notification configuration to the SwrveConfig and pass into SwrveSDK.createInstance.

val config = SwrveConfig()
var channel: NotificationChannel? = null
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    channel = NotificationChannel(
         "123",
         "Devapp swrve default channel",
          NotificationManager.IMPORTANCE_DEFAULT
    )
    val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
    notificationManager?.createNotificationChannel(channel)
}
val notificationConfig = SwrveNotificationConfig.Builder(R.drawable.logo1, R.drawable.logo2, channel)
    .activityClass(MainActivity::class.java)
    .largeIconDrawableId(R.drawable.swrve_s_solid)
    .accentColorHex("#3949AB")
    .build()
config.notificationConfig = notificationConfig
SwrveSDK.createInstance(this, <app_id>, <api_key>, config)

SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)
SwrveSDK.setSilentPushListener(object : SwrveSilentPushListener {
    override fun onSilentPush(context: Context, payload: JSONObject) {
        // NOTE: Do not call the Swrve SDK from this context
        // NOTE: This is called directly from the push service in the background
        // Your code here
    }
})

SwrveSDK.createInstance(this, <app_id>, "<api_key>", config);
SwrveSDK.setSilentPushListener(new SwrveSilentPushListener() {
    @Override
    public void onSilentPush(Context context, JSONObject payload) {
        // NOTE: Do not call the Swrve SDK from this context
        // NOTE: This is called directly from the push service in the background

        // Your code here
    }
});

val config = SwrveConfig()
config.notificationListener = object : SwrvePushNotificationListener {
    override fun onPushNotification(payload: JSONObject) {
        // CUSTOM CODE HERE
    }
}
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)
...

SwrveConfig config = new SwrveConfig();
config.setNotificationListener(new SwrvePushNotificationListener() {
   @Override
   public void onPushNotification(JSONObject payload) {
      // CUSTOM CODE HERE                
   }
});
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config);
...

val config = SwrveConfig()
val inAppConfigBuilder = SwrveInAppMessageConfig.Builder()
    .messageListener(object : SwrveInAppMessageListener {
        override fun onAction(
            context: Context,
            action: SwrveMessageAction,
            messageDetails: SwrveMessageDetails,
            selectedButton: SwrveMessageButtonDetails?
        ) {
            // See messageDetails object for campaign meta data available
            // See selectedButton object for button meta data available
            // Note: selectedButton will be null for SwrveImpression callback.

            when (action) {
                SwrveMessageAction.Impression -> {
                    // process Impression callback
                }
                SwrveMessageAction.Custom -> {
                    // process Custom callback
                    // SwrveSDK will handle deep links internally.
                    // To override this behavior, implement the SwrveDeeplinkListener
                }
                SwrveMessageAction.Dismiss -> {
                    // process Dismiss callback
                }
                SwrveMessageAction.CopyToClipboard -> {
                    // process CopyToClipboard callback
                }
                else -> {
                    // Handle default case
                }
            }
        }
    })

config.inAppMessageConfig = inAppConfigBuilder.build()

// Callback must be configured before SwrveSDK is instantiated
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)

SwrveConfig config = new SwrveConfig();
SwrveInAppMessageConfig.Builder inAppConfigBuilder = new SwrveInAppMessageConfig.Builder().messageListener(new SwrveInAppMessageListener() {
    @Override
    public void onAction(Context context, SwrveMessageAction action, SwrveMessageDetails messageDetails, SwrveMessageButtonDetails selectedButton) {
        
        // See messageDetails object for campaign meta data available 
        // See selectedButton object for button meta data available 
        // Note: selectedButton will be nil for SwrveImpression callback.
        
        switch (action) {
             case Impression:
               // process Impression callback
             break;
             case Custom:
              // process Custom callback  
              // SwrveSDK will handle deep links internally.
              // to override this behavior you can implement the SwrveDeeplinkListener
             break;   
             case Dismiss:
               // process Dismiss callback            
             break;
             case CopyToClipboard:
               // process CopyToClipboard callback           
             break;
             default:
             break;                                                 
         }               
    }
});

config.setInAppMessageConfig(inAppConfigBuilder.build());

// callback must be configured before SwrveSDK is instantiated 
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config);

val config = SwrveConfig()
val inAppConfigBuilder = SwrveInAppMessageConfig.Builder()
            .messageListener { context, action, messageDetails, selectedButton ->
                if (action == SwrveMessageAction.Custom) {
                    val EVENT_DELAY_MILLISECONDS = 250L
                    val timedService = Executors.newSingleThreadScheduledExecutor()

                    timedService.schedule({
                        selectedButton?.actionString?.let { actionString ->
                            val uri = Uri.parse(actionString)
                            if (uri.scheme == "swrve") {
                                uri.queryParameterNames.forEach { key ->
                                    val value = uri.getQueryParameter(key)
                                    if (key == "event") {
                                        SwrveSDK.event(value!!)
                                    }
                                    SwrveSDK.sendQueuedEvents()
                                }
                            }
                        }
                    }, EVENT_DELAY_MILLISECONDS, TimeUnit.MILLISECONDS)
                }
            }

config.inAppMessageConfig = inAppConfigBuilder.build()

// callback must be configured before SwrveSDK is instantiated 
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)

SwrveConfig config = new SwrveConfig();
SwrveInAppMessageConfig.Builder inAppConfigBuilder = new SwrveInAppMessageConfig.Builder().messageListener(new SwrveInAppMessageListener()  {
    @Override
      public void onAction(Context context, SwrveMessageAction action, SwrveMessageDetails messageDetails, SwrveMessageButtonDetails selectedButton) {
        if (action == Custom) {
          final int EVENT_DELAY_MILLISECONDS = 250;
          ScheduledExecutorService timedService = Executors.newSingleThreadScheduledExecutor();
          timedService.schedule(new Runnable() {
            @Override
            public void run() {
                Uri uri = Uri.parse(selectedButton.getActionString());
                if (uri.getScheme().equals("swrve")) {
                    for( String key: uri.getQueryParameterNames() ) {
                        final String value = uri.getQueryParameter(key);

                        if(key.equals("event") ) {
                            SwrveSDK.event(value);
                        }
                        SwrveSDK.sendQueuedEvents();
                    }
                }
            }, EVENT_DELAY_MILLISECONDS, TimeUnit.MILLISECONDS);
         }
       }
    }
});

config.setInAppMessageConfig(inAppConfigBuilder.build());

// callback must be configured before SwrveSDK is instantiated 
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config);

val inAppConfigBuilder = SwrveInAppMessageConfig.Builder()
    .personalizedTextBackgroundColor(Color.RED)
    .personalizedTextForegroundColor(Color.YELLOW)
    .personalizedTextTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL))
    .defaultBackgroundColor(ColorUtils.setAlphaComponent(Color.GREEN, 125))
config.inAppMessageConfig = inAppConfigBuilder.build()

SwrveInAppMessageConfig.Builder inAppConfigBuilder = new 
    SwrveInAppMessageConfig.Builder()
    .personalizedTextBackgroundColor(Color.RED)
    .personalizedTextForegroundColor(Color.YELLOW)
    .personalizedTextTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
    .defaultBackgroundColor(ColorUtils.setAlphaComponent(Color.GREEN, 125));
config.setInAppMessageConfig(inAppConfigBuilder.build());

val defaultDrawable = ContextCompat.getDrawable(context, R.drawable.story_dismiss_default)
val pressedDrawable = ContextCompat.getDrawable(context, R.drawable.story_dismiss_pressed)
val focusedDrawable = pressedDrawable
val stateListDrawable = StateListDrawable().apply {
    addState(intArrayOf(android.R.attr.state_pressed), pressedDrawable)
    addState(intArrayOf(android.R.attr.state_focused), focusedDrawable)
    addState(intArrayOf(), defaultDrawable)
}
val inAppConfig = SwrveInAppMessageConfig.Builder()
    .storyDismissButton(stateListDrawable)
    .build()
val config = SwrveConfig().apply {
    inAppMessageConfig = inAppConfig
}
SwrveSDK.createInstance(this, <app_id>, "<app_key>", config)

Drawable defaultDrawable = ContextCompat.getDrawable(context, R.drawable.story_dismiss_default);
Drawable pressedDrawable = ContextCompat.getDrawable(context, R.drawable.story_dismiss_pressed);
Drawable focusedDrawable = pressedDrawable;
StateListDrawable stateListDrawable = new StateListDrawable();
stateListDrawable.addState(new int[]{android.R.attr.state_pressed}, pressedDrawable);
stateListDrawable.addState(new int[]{android.R.attr.state_focused}, focusedDrawable);
stateListDrawable.addState(new int[]{}, defaultDrawable);
SwrveInAppMessageConfig.Builder inAppConfigBuilder = new SwrveInAppMessageConfig.Builder().storyDismissButton(stateListDrawable);
SwrveInAppMessageConfig inAppConfig = inAppConfigBuilder.build();
SwrveConfig config = new SwrveConfig();
config.setInAppMessageConfig(inAppConfig);
SwrveSDK.createInstance(this, <app_id>, "<app_key>", config);

val embeddedListener = SwrveEmbeddedListener { context, message, personalizationProperties, isControl ->
    // Perform your own message rendering
    println(message.data) // `data` is where your JSON resides
}

// Set your callback as part of your configuration
val embeddedMessageConfig = SwrveEmbeddedMessageConfig.Builder()
    .embeddedListener(embeddedListener)
    .build()

config.embeddedMessageConfig = embeddedMessageConfig

// Callback must be configured before SwrveSDK is instantiated
SwrveSDK.createInstance(this, <app_id>, "<api_key>", config)

SwrveEmbeddedListener embeddedListener = (context, message, personalizationProperties, isControl) -> {
    // perform your own message rendering
    System.out.println(message.getData()); //getData is where your JSON resides
};

// set your callback as part of your configuration.
SwrveEmbeddedMessageConfig embeddedMessageConfig = new SwrveEmbeddedMessageConfig.Builder()
        .embeddedListener(embeddedListener)
        .build();
config.setEmbeddedMessageConfig(embeddedMessageConfig);

// callback must be configured before SwrveSDK is instantiated 
SwrveSDK.createInstance(this,<app_id> , "<api_key>", config);

val embeddedListener = SwrveEmbeddedListener { context, message, personalizationProperties, isControl ->
    if (isControl) {
        // This campaign should not be shown to the user. Send an impression event for reporting.
        SwrveSDK.embeddedControlMessageImpressionEvent(message)
    } else {
        // Returns the message data with personalization resolved. It will be null if it couldn't resolve.
        val resolvedMessageData = SwrveSDK.getPersonalizedEmbeddedMessageData(message, personalizationProperties)
        
        // Continue with normal logic
        // If you want to track an impression event
        SwrveSDK.embeddedMessageWasShownToUser(message)
        
        // The message object returns a list of strings representing the button options.
        // In this example, we take the first button from the list and send a click event.
        val buttons = message.buttons
        if (!buttons.isNullOrEmpty() && buttons.size == 1) {
            val buttonName = buttons[0]
            SwrveSDK.embeddedMessageButtonWasPressed(message, buttonName)
        }
    }
}

 SwrveEmbeddedListener embeddedListener = (context, message, personalizationProperties, isControl) -> {

        if (isControl) {
            // this campaign should not be shown to user, to help with reporting you should use the api below to send us an impression event

            SwrveSDK.embeddedControlMessageImpressionEvent(message);
        } else {

// returns the message data with personalization resolved. It will be null if it could not resolve.
            String resolvedMessageData = SwrveSDK.getPersonalizedEmbeddedMessageData(message, personalizationProperties);
            // continue with normal logic

            // If you want to track an impression event
            SwrveSDK.embeddedMessageWasShownToUser(message);

            // The message object returns a list of strings representing the button options.
            // In this example we are taking out the first button from the list and sending a click event
            if (message.getButtons() != null && message.getButtons().size() = 1) {
               String buttonName = message.getButtons().get(0);
               SwrveSDK.embeddedMessageButtonWasPressed(message, buttonName);
            }
        }

    };

val payload = mapOf(
    "key1" to "value1",
    "key2" to "value2"
)

SwrveSDK.event("custom.event_name", payload)

Map<String,String> payload = new HashMap<String, String>();
payload.put("key1", "value1");
payload.put("key2", "value2");
SwrveSDK.event("custom.event_name", payload);

val payload = mapOf(
    "time" to "100",
    "step" to "5"
)
SwrveSDK.event("tutorial.start", payload)

Map<String,String> payload = new HashMap<String, String>();
payload.put("time", "100");
payload.put("step", "5");
SwrveSDK.event("tutorial.start", payload);

val attributes = mapOf(
    "premium" to "true",
    "level" to "12",
    "balance" to "999"
)
SwrveSDK.userUpdate(attributes)

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("premium", "true");
attributes.put("level", "12");
attributes.put("balance", "999");
SwrveSDK.userUpdate(attributes);

SwrveSDK.userUpdate("last_purchase", Date())

SwrveSDK.userUpdate("last_purchase", new Date());

val item = "some.item"
val currency = "gold"
val cost = 99
val quantity = 1
SwrveSDK.purchase(item, currency, cost, quantity)

String item = "some.item";
String currency = "gold";
int cost = 99;
int quantity = 1;
SwrveSDK.purchase(item, currency, cost, quantity);

val givenCurrency = "gold"
val givenAmount = 99.0
SwrveSDK.currencyGiven(givenCurrency, givenAmount)

String givenCurrency = "gold";
double givenAmount = 99;
SwrveSDK.currencyGiven(givenCurrency, givenAmount);

fun iap(
    quantity: Int,
    productId: String,
    productPrice: Double,
    currency: String
)

fun iap(
    quantity: Int,
    productId: String,
    productPrice: Double,
    currency: String,
    rewards: SwrveIAPRewards
)

public void iap(int quantity,
                String productId,
                double productPrice,
                String currency);

public void iap(int quantity,
                String productId,
                double productPrice,
                String currency,
                SwrveIAPRewards rewards);

fun iapPlay(
    productId: String,
    productPrice: Double,
    currency: String,
    receipt: String,
    receiptSignature: String
)

fun iapPlay(
    productId: String,
    productPrice: Double,
    currency: String,
    rewards: SwrveIAPRewards,
    receipt: String,
    receiptSignature: String
)

public void iapPlay(String productId,
                    double productPrice,
                    String currency,
                    String receipt,
                    String receiptSignature);

public void iapPlay(String productId,
                    double productPrice,
                    String currency,
                    SwrveIAPRewards rewards,
                    String receipt,
                    String receiptSignature);

// Start an in-app purchase for the product with purchaseProductId
try {
    val buyIntentBundle = mService.getBuyIntent(
        3,
        packageName,
        purchaseProductId,
        "inapp",
        "extra"
    )
    val pendingIntent = buyIntentBundle.getParcelable<PendingIntent>("BUY_INTENT")
    startIntentSenderForResult(
        pendingIntent.intentSender,
        purchaseRequestCode,
        Intent(),
        0,
        0,
        0
    )
} catch (e: RemoteException) {
    e.printStackTrace()
} catch (e: SendIntentException) {
    e.printStackTrace()
}

// start an in-app purchase for the product with purchaseProductId
try {
   Bundle buyIntentBundle = mService.getBuyIntent(3,
                                                  getPackageName(),
                                                  purchaseProductId,
                                                  "inapp",
                                                  "extra");
    PendingIntent pendingIntent = buyIntentBundle.getParcelable("BUY_INTENT");
    startIntentSenderForResult(pendingIntent.getIntentSender(),
                               purchaseRequestCode,
                               new Intent(), 
                               Integer.valueOf(0),
                               Integer.valueOf(0),
                               Integer.valueOf(0));
} catch (RemoteException e) {
    e.printStackTrace();
} catch (SendIntentException e) {
    e.printStackTrace();
}

// Callback on purchase finished
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == purchaseRequestCode) {
        val responseCode = data?.getIntExtra("RESPONSE_CODE", 0) ?: 0
        // Get the receipt JSON string and the receipt signature
        val receipt = data?.getStringExtra("INAPP_PURCHASE_DATA")
        val receiptSignature = data?.getStringExtra("INAPP_DATA_SIGNATURE")
        // Make sure the purchase succeeded
        if (resultCode == RESULT_OK && responseCode == 0) {
            // Fill in the product details and the receipt data
            SwrveSDK.iapPlay(
                purchaseProductId,
                purchasePrice,
                purchaseCurrency,
                receipt,
                receiptSignature
            )
        }
    }
}

@Override
// callback on purchase finished
protected void onActivityResult(int requestCode, int resultCode, Intent data) { 

    if (requestCode == purchaseRequestCode) {
        int responseCode = data.getIntExtra("RESPONSE_CODE", 0);
        // get the receipt JSON string and the receipt signature
        String receipt = data.getStringExtra("INAPP_PURCHASE_DATA");
        String receiptSignature = data.getStringExtra("INAPP_DATA_SIGNATURE");

        // make sure the purchase succeeded
        if (resultCode == RESULT_OK && responseCode == 0) {
            // fill in the product details and the receipt data
            SwrveSDK.iapPlay(purchaseProductId,
                             purchasePrice,
                             purchaseCurrency,
                             receipt,
                             receiptSignature);
        }
    }
}

val purchaseRewards = SwrveIAPRewards()
purchaseRewards.addCurrency(virtualCurrency, 200)
purchaseRewards.addItem(inAppItem, 1)

SwrveIAPRewards purchaseRewards = new SwrveIAPRewards();
purchaseRewards.addCurrency(virtualCurrency, 200);
purchaseRewards.addItem(inAppItem, 1);

// Get the SwrveResourceManager which holds all up-to-date attribute values
val resourceManager = SwrveSDK.getResourceManager()

// Then, whenever you need to use a resource, pull it from the resourceManager.
// For example, use the following to set some welcome text in your app to the
// current value of the attribute "welcome_text" of the resource "new_app_config"
// defaulting to "Welcome!" when the attribute is unavailable
welcomeScreen.setMessageText(
    resourceManager.getAttributeAsString("new_app_config", "welcome_text", "Welcome!")
)

// Get the SwrveResourceManager which holds all up-to-date attribute values
SwrveResourceManager resourceManager = SwrveSDK.getResourceManager();

// Then, whenever you need to use a resource, pull it from the resourceManager.
// For example, use the following to set some welcome text in your app to the
// current value of the attribute "welcome_text" of the resource "new_app_config"
// defaulting to "Welcome!" when attribute is unavailable
welcomeScreen.setMessageText(resourceManager.getAttributeAsString("new_app_config", "welcome_text", "Welcome!"));

SwrveSDK.setResourcesListener(object : SwrveResourcesListener {
    override fun onResourcesUpdated() {
        // Callback functionality
    }
})

SwrveSDK.setResourcesListener(new SwrveResourcesListener() {
    public void onResourcesUpdated() {
        // Callback functionality
    }
});