Android SDK

allprojects {
    repositories {
        /* other repositories */
        maven {
            setUrl("https://maven.ravelin.com/public/repositories/core-android/")
        }
    }
}

dependencies {
    /* Other dependencies */
    implementation 'com.ravelin.sdk:ravelin-core:5.0.0'
    implementation 'com.ravelin.sdk:ravelin-encrypt:5.0.0'
}

dependencies {
    /* Other dependencies */
    implementation("com.ravelin.sdk:ravelin-core:5.0.0")
    implementation("com.ravelin.sdk:ravelin-encrypt:5.0.0")
}

allprojects {
    repositories {
        /* other repositories */
        maven {
            name "Ravelin"
            credentials {
                username "$ravelinRepoUsername"
                password "$ravelinRepoPassword"
            }
            url "https://maven.ravelin.com/repositories/releases/"
        }
    }
}

allprojects {
    repositories {
        /* other repositories */
        maven {
            credentials {
                username = properties["ravelinRepoUsername"] as? String
                password = properties["ravelinRepoPassword"] as? String
            }
            setUrl("https://maven.ravelin.com/repositories/releases/")
        }
    }
}

dependencies {
    /* other dependencies */
    implementation 'com.ravelin.sdk:ravelin-core:3.0.3'
    implementation 'com.ravelin.sdk:ravelin-encrypt:3.0.3'
}

dependencies {
    /* other dependencies */
    implementation("com.ravelin.sdk:ravelin-core:3.0.3")
    implementation("com.ravelin.sdk:ravelin-encrypt:3.0.3")
}

allprojects {
    repositories {
        /* other repositories */
        flatDir {
            dirs 'libs'
        }
    }
}

allprojects {
    repositories {
        /* other repositories */
        flatDir {
            dirs("libs")
        }
    }
}

dependencies {
    implementation(name: 'ravelin', ext: 'aar')
}

dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
}

dependencies {
    /* other dependencies */
    implementation 'com.ravelin.sdk:ravelin-core:5.0.0'
    implementation 'com.ravelin.sdk:ravelin-encrypt:5.0.0'
}

    <application
        android:dataExtractionRules="@xml/backup_rules_31_and_above"
        android:fullBackupContent="@xml/backup_rules_until_30"
        tools:targetApi="s"
    />

    <?xml version="1.0" encoding="utf-8"?>
    <data-extraction-rules disableIfNoEncryptionCapabilities="false">
        <include
            domain="sharedpref"
            path="." />
        <exclude
            domain="sharedpref"
            path="my_secret_shared_pref_data.xml" />
        <exclude
            domain="sharedpref"
            path="my_com.ravelin.core_shared_pref_data.xml" />
    </data-extraction-rules>

    <?xml version="1.0" encoding="utf-8"?>
    <full-backup-content>
        <include
            domain="sharedpref"
            path="." />
        <exclude
            domain="sharedpref"
            path="my_secret_shared_pref_data.xml" />
        <exclude
            domain="sharedpref"
            path="my_com.ravelin.core_shared_pref_data.xml" />
    </full-backup-content>

// Add the following to your build.gradle.kts file
compileOptions {
    // Other configurations ...
    isCoreLibraryDesugaringEnabled = true 
}

// Add the following dependency to your build.gradle.kts file:
dependencies {
    // Other dependencies
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.0.4")
}

// MyApplication.kt

// using callbacks
RavelinSDK.createInstance(this, "publishable_key_live", object : RavelinCallback<RavelinSDK>() {
    override fun success(ravelin: RavelinSDK) {
        Log.d("Ravelin Setup Success", "hooray")
    }

    override fun failure(error: RavelinError) {
        Log.e("Ravelin Setup Error", error.message)
    }
})

// without a callback
val ravelin: RavelinSDK = RavelinSDK.createInstance(this, "publishable_key_live")

// MyActivity.kt

// using callback
RavelinSDK.getSharedInstance(object : RavelinCallback<RavelinSDK>() {
    override fun success(ravelin: RavelinSDK) {
        Log.d("Ravelin Setup Success", "hooray")
    }

    override fun failure(error: RavelinError) {
        Log.e("Ravelin Setup Error", error.message)
    }
})

// without a callback
val ravelin: RavelinSDK = RavelinSDK.getSharedInstance()

RavelinSDK.cleanup(object : RavelinCallback<String>() {
    override fun success(response: String) {
        Log.d("Ravelin Setup Success", response)
    }

    override fun failure(error: RavelinError) {
        Log.e("Ravelin Setup Error", error.message)
    }
})

// MyApplication.java

// null-safe inside callback
class Example {
    RavelinSDK instance = RavelinSDK.Companion.createInstance(this, "publishable_key_live", new RavelinCallback<RavelinSDK>() {
        @Override
        public void success(RavelinSDK ravelinSDK) {
            Log.d("Ravelin Setup Success", "hooray");
        }

        @Override
        public void failure(@NotNull RavelinError ravelinError) {
            Log.e("Ravelin Setup Error", ravelinError.getMessage());
        }
    });

    // no callback, not null safe
    RavelinSDK instance2 = RavelinSDK.Companion.createInstance(this, "publishable_key_live");
}

// MyActivity.java

// null-safe with handled error message
class Example {
    RavelinSDK instance1 = RavelinSDK.getSharedInstance(new RavelinCallback<RavelinSDK>() {
        @Override
        public void success(RavelinSDK ravelinSDK) {
            Log.d("Ravelin Setup Success", "hooray");
        }

        @Override
        public void failure(@NotNull RavelinError ravelinError) {
            Log.e("Ravelin Setup Error", error.getMessage());
        }
    });

    // nullable, no error message
    RavelinSDK instance2 = RavelinSDK.Companion.getSharedInstance();
}

class Example {
    void main() {
        RavelinSDK.Companion.cleanup(new RavelinCallback<String>() {
            @Override
            public void success(String response) {
                Log.d("Ravelin Setup Success", response);
            }

            @Override
            public void failure(@NotNull RavelinError ravelinError) {
                Log.e("Ravelin Setup Error", ravelinError.getMessage());
            }
        });
    }
}

class YourApplication : Application(), Configuration.Provider {
    //...

    override fun onCreate() {
        super.onCreate()
        val configuration = workManagerConfiguration
        WorkManager.initialize(this, configuration) // call only for WorkManager older than 2.1.0 
    }

    override fun getWorkManagerConfiguration(): Configuration =
        Configuration.Builder()
            .build()
    //...
}

public class YourApplication extends Application implements Configuration.Provider {
    //...

    @Override
    public void onCreate() {
        super.onCreate();
        Configuration config = getWorkManagerConfiguration();
        WorkManager.initialize(this, config); // call only for WorkManager older than 2.1.0 
    }

    @NonNull
    @NotNull
    @Override
    public Configuration getWorkManagerConfiguration() {
        return new Configuration.Builder().build();
    }

    //...
}

val cardDetails = CardDetails("1234 1234 1234 1234", "02", "18", "Dr Jilly McJillson")

// null safe callback
RavelinEncrypt().encryptCard(cardDetails, "RSA-Key",
    object : EncryptCallback<EncryptedCard>() {
        override fun failure(error: EncryptError) {
            Log.d("Card encryption Error", error.message)
        }
        override fun success(result: EncryptedCard?) {
            Log.d("Card encryption Success", result.toString())
        }
    })

// nullable
val encryptedCard = RavelinEncrypt().encryptCard(cardDetails, "2|rsakeykeykeykeykeykey")

class Example {
    final CardDetails cardDetails = new CardDetails("1234 1234 1234 1234", "02", "18", "Dr Jilly McJillson");

    // null safe callback
    EncryptedCard encryptedCard = RavelinEncrypt().encryptCard(cardDetails, "RSA-Key",
        new EncryptCallback<CardDetails>() {
            public void failure(EncryptError error) {
                Log.d("Card encryption Error", error.getMessage());
            }

            public void success(CardDetails result) {
                Log.d("Card encryption Success", result.toString());
            }
        });
}

// nullable
class Example {
    final EncryptedCard encryptedCard = RavelinEncrypt().encryptCard(cardDetails, "2|rsakeykeykeykeykeykey");
}

val cardDetails = CardDetails("1234 1234 1234 1234", "02", "18", "Dr Jilly McJillson")

cardDetails.validate(object : EncryptCallback<CardDetails>() {
    override fun failure(error: EncryptError) {
        Log.d("Card Validation Error", error.message)
    }

    override fun success(result: CardDetails?) {
        Log.d("Card Validation Success", "hooray")
    }
})

RavelinEncrypt().encryptCard(cardDetails, "RSA-Key",
    object : EncryptCallback<EncryptedCard>() {
        override fun failure(error: EncryptError) {
            Log.d("Card encryption Error", error.message)
        }
        override fun success(result: EncryptedCard?) {
            Log.d("Card encryption Success", result.toString())
        }
    })

class Example {
    final CardDetails cardDetails = new CardDetails("1234 1234 1234 1234", "02", "18", "Dr Jilly McJillson");

    // null safe callback
    CardDetailks cardDetails = cardDetails.validate(new EncryptCallback<CardDetails>() {
        @Override
        public void success(CardDetails result) {
            Log.e("Card Validation Success", "hooray");
        }

        @Override
        public void failure(EncryptError error) {
            Log.e("Card Validation Error", error.getMessage());
        }
    });

    EncryptedCard encryptedCard = RavelinEncrypt().encryptCard(cardDetails, "RSA-Key",
        new EncryptCallback<CardDetails>() {

            @Override
            public void failure(EncryptError error) {
                Log.d("Card encryption Error", error.getMessage());
            }

            @Override
            public void success(CardDetails result) {
                Log.d("Card encryption Success", result.toString());
            }
        });
}

// set Customer ID
ravelin.customerId = "12346578"

// immediately call asynchronously
ravelin.trackFingerprint(object : RavelinRequestCallback() {
    override fun success(payload: Array<ResponsePayload>?) {
        payload?.forEachIndexed { index, responsePayload ->
            Log.d(TAG, "API Request Success with payload $index = $responsePayload")
        }
    }

    override fun failure(error: RavelinError) {
        Log.e("API Request Error", error.message)
    }
})

class Example {
    // set Customer ID
    void main() {
        ravelin.setCustomerId("12346578");
        // immediately call asynchronously
        ravelin.trackFingerprint(new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackPage(
    "Product List - Toothbrushes",
    linkedMapOf("Property 1" to "Custom", "Property 2" to "Data"),
    object : RavelinRequestCallback() {
        override fun success(payload: Array<ResponsePayload>?) {
            payload?.forEachIndexed { index, responsePayload ->
                Log.d(TAG, "API Request Success with payload $index = $responsePayload")
            }
        }

        override fun failure(error: RavelinError) {
            Log.e("API Request Error", error.message)
        }
    })

class Example {
    void main() {
        // immediately call asynchronously
        final LinkedHashMap<String, String> map = new LinkedHashMap<>();
        map.put("Proeprty 1", "Custom");
        map.put("Proeprty 2", "Data");

        ravelin.trackPage("Product List - Toothbrushes", map, new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackSearch(
    "Product List - Toothbrushes",
    "search value",
    object : RavelinRequestCallback() {
        override fun success(payload: Array<ResponsePayload>?) {
            payload?.forEachIndexed { index, responsePayload ->
                Log.d(TAG, "API Request Success with payload $index = $responsePayload")
            }
        }

        override fun failure(error: RavelinError) {
            Log.e("API Request Error", error.message)
        }
    })

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackSearch("Product List - Toothbrushes", "Search value", new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackSelectOption(
    "Product Page",
    "Option",
    "Option Value",
    object : RavelinRequestCallback() {
        override fun success(payload: Array<ResponsePayload>?) {
            payload?.forEachIndexed { index, responsePayload ->
                Log.d(TAG, "API Request Success with payload $index = $responsePayload")
            }
        }

        override fun failure(error: RavelinError) {
            Log.e("API Request Error", error.message)
        }
    })

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackSelectOption("Product Page", "Option", "Option Value", new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackAddToCart("Product Page", "Item Name", 5, object : RavelinRequestCallback() {
    override fun success(payload: Array<ResponsePayload>?) {
        payload?.forEachIndexed { index, responsePayload ->
            Log.d(TAG, "API Request Success with payload $index = $responsePayload")
        }
    }

    override fun failure(error: RavelinError) {
        Log.e("API Request Error", error.message)
    }
})

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackAddToCart("Product Page ", "Item Name", 5, new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackAddToWishlist("Product Page", "Item Name", object : RavelinRequestCallback() {
    override fun success(payload: Array<ResponsePayload>?) {
        payload?.forEachIndexed { index, responsePayload ->
            Log.d(TAG, "API Request Success with payload $index = $responsePayload")
        }
    }

    override fun failure(error: RavelinError) {
        Log.e("API Request Error", error.message)
    }
})

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackAddToWishlist("Product Page", "Item Name", new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackLanguageChange("Product Page", "en-us", object : RavelinRequestCallback() {
    override fun success(payload: Array<ResponsePayload>?) {
        payload?.forEachIndexed { index, responsePayload ->
            Log.d(TAG, "API Request Success with payload $index = $responsePayload")
        }
    }

    override fun failure(error: RavelinError) {
        Log.e("API Request Error", error.message)
    }
})

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackLanguageChange("Product Page", "en-us", new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackCurrencyChange("Product Page", "EUR", object : RavelinRequestCallback() {
    override fun success(payload: Array<ResponsePayload>?) {
        payload?.forEachIndexed { index, responsePayload ->
            Log.d(TAG, "API Request Success with payload $index = $responsePayload")
        }
    }

    override fun failure(error: RavelinError) {
        Log.e("API Request Error", error.message)
    }
})

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackCurrencyChange("Product Page", "EUR", new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackViewContent("Product Page", "Content Type", object : RavelinRequestCallback() {
    override fun success(payload: Array<ResponsePayload>?) {
        payload?.forEachIndexed { index, responsePayload ->
            Log.d(TAG, "API Request Success with payload $index = $responsePayload")
        }
    }

    override fun failure(error: RavelinError) {
        Log.e("API Request Error", error.message)
    }
})

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackViewContent("Product Page", "Content Type", new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackEvent(
    "app open",
    "login activity",
    linkedMapOf(
        "Property 1" to "Custom",
        "Property 2" to 1,
        "Property 3" to true,
        "Property4" to null,
        "Property 5" to listOf(1, null, true, 1.234)
    ),
    object : RavelinRequestCallback() {
        override fun success(payload: Array<ResponsePayload>?) {
            payload?.forEachIndexed { index, responsePayload ->
                Log.d(TAG, "API Request Success with payload $index = $responsePayload")
            }
        }

        override fun failure(error: RavelinError) {
            Log.e("API Request Error", error.message)
        }
    })

class Example {
    void main() {
        final LinkedHashMap<String, String> map = new LinkedHashMap<>();
        map.put("Proeprty 1", "Custom");
        map.put("Proeprty 2", 1);
        map.put("Proeprty 3", true);
        map.put("Proeprty 4", null);
        List<Object> list = new ArrayList();
        list.add(1);
        list.add(null);
        list.add(true);
        list.add(1.234);
        // immediately call asynchronously
        ravelin.trackEvent("app open", "login activity", map, new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackLogIn(
    "15464811",
    "login activity",
    linkedMapOf("Class" to "Mage"),
    object : RavelinRequestCallback() {
        override fun success(payload: Array<ResponsePayload>?) {
            payload?.forEachIndexed { index, responsePayload ->
                Log.d(TAG, "API Request Success with payload $index = $responsePayload")
            }
        }

        override fun failure(error: RavelinError) {
            Log.e("API Request Error", error.message)
        }
    })

class Example {
    void main() {
        final HashMap<String, String> map = new LinkedHashMap<>();
        map.put("Class", "Mage");

        // immediately call asynchronously
        ravelin.trackLogIn("app open", "login activity", map, new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackLogOut(
    "User Account",
    linkedMapOf("Class" to "Mage"),
    object : RavelinRequestCallback() {
        override fun success(payload: Array<ResponsePayload>?) {
            payload?.forEachIndexed { index, responsePayload ->
                Log.d(TAG, "API Request Success with payload $index = $responsePayload")
            }
        }

        override fun failure(error: RavelinError) {
            Log.e("API Request Error", error.message)
        }
    })

class Example {
    void main() {
        final HashMap<String, String> map = new LinkedHashMap<>();
        map.put("Class", "Mage");

        // immediately call asynchronously
        ravelin.trackLogOut("login activity", map, new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(@NotNull RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

// immediately call asynchronously
ravelin.trackPaste("checkout activity", pastedCharacters, object : RavelinRequestCallback() {
    override fun success(payload: Array<ResponsePayload>?) {
        payload?.forEachIndexed { index, responsePayload ->
            Log.d(TAG, "API Request Success with payload $index = $responsePayload")
        }
    }

    override fun failure(error: RavelinError) {
        Log.e("API Request Error", error.message)
    }
})

class Example {
    void main() {
        // immediately call asynchronously
        ravelin.trackPaste("login activity", pastedCharacters, new RavelinRequestCallback() {
            @Override
            public void success(@Nullable ResponsePayload[] payload) {
                if (payload != null) {
                    for (ResponsePayload responsePayload : payload) {
                        Log.i("MainActivity", "Ravelin payload = " + responsePayload);
                    }
                }
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("API Request Error", error.getMessage());
            }
        });
    }
}

val view = // Your EditText

    view.addTextChangedListener(
        PasteListener("page", object : PasteListener.OnPaste() {
            fun pasted() {
                Log.d("Paste Event", "user has pasted some content")
            }
        })
    )

class Example {
    void main() {
        EditText view = // Your EditText

            view.addTextChangedListener(
                new PasteListener("page", new PasteListener.OnPaste() {

                    @Override
                    public void pasted() {
                        Log.d("Paste Event", "user has pasted some content");
                    }
                })
            );
    }
}

class Example {
    fun getDeviceId(): String = run {
        val ravelinSdk = RavelinSDK.getSharedInstance()
        ravelinSdk.getDeviceId()
    }
}

class Example {
    String getDeviceId() {
        RavelinSdk ravelinSdk = RavelinSDK.Companion.getSharedInstance();
        if (ravelinSdk != null) {
            return ravelinSdk.getDeviceId();
        } else {
            return null;
        }
    }
}

class Example {
    
    fun createInstance(app: Application, myDeviceId: String, myAppVersion: String) {
        RavelinSDK.createInstance(this, "api_key_123456789", myAppVersion, myDeviceId,
            object : RavelinCallback<RavelinSDK>() {

                override fun success(instance: RavelinSDK) {
                    Log.i("Ravelin Setup Success", "deviceId = ${instance.getDeviceId()}")
                }

                override fun failure(error: RavelinError) {
                    Log.e("Ravelin Setup Error", error.message)
                }
            })
    }
}

class Example {
    void createInstance(Application app, String myDeviceId, String myAppVersion) {
        RavelinSDK.Companion.createInstance(app, "api_key_123456789", myAppVersion, myDeviceId,
                new RavelinCallback<RavelinSDK>() {

                    @Override
                    public void success(RavelinSDK instance) {
                        Log.i("Ravelin Setup Success", "deviceId = " + instance.getDeviceId());
                    }

                    @Override
                    public void failure(RavelinError error) {
                        Log.e("Ravelin Setup Error", error.getMessage());
                    }
                });
    }
}

class ShopApplication : Application() {
    override fun onCreate() {
        // Create instance referencing the application.
        // This can be done anywhere if the application does not extend Application
        RavelinSDK.createInstance(this, "api_key_123456789",
            object : RavelinCallback<RavelinSDK>() {

                override fun success(instance: RavelinSDK) {
                    Log.e("Ravelin Setup Success", "hooray")
                }

                override fun failure(error: RavelinError) {
                    Log.e("Ravelin Setup Error", error.message)
                }
            })
    }
}


class ShopActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val customerId = "1234" // get customerId from your login process

        val ravelin = RavelinSDK.getSharedInstance(object : RavelinCallback<RavelinSDK>() {
            override fun success(result: RavelinSDK) {
                result.customerId =
                    customerId // set customer id either directly or via trackLogin method
                // this id will then be sent with all subsequent tracking events
                result.orderId = "your own order ID" // set order id to your own order reference
                result.trackPage("Shopping Page")
            }

            override fun failure(error: RavelinError) {
                Log.e("Ravelin Setup Error", error.message)
            }
        })
        val cardNumberTextView = findViewById<TextView>(R.id.pan)
        val expirationMonthTextView = findViewById<TextView>(R.id.expiration_month)
        val expirationYearTextView = findViewById<TextView>(R.id.expiration_year)
        val nameOnCardTextView = findViewById<TextView>(R.id.name_on_card)

        findViewById<Button>(R.id.payButton).setOnClickListener {
            val pan = cardNumberTextView.text.toString()
            val month = expirationMonthTextView.text.toString()
            val year = expirationYearTextView.text.toString()
            val name = nameOnCardTextView.text.toString()

            val cardDetails = CardDetails(pan, month, year, name)

            if (ravelin != null) {
                ravelin.encryptCard(
                    cardDetails,
                    "RSA-KEY",
                    object : RavelinCallback<EncryptedCard>() {
                        override fun success(result: EncryptedCard) {
                            Log.e("Card Encryption Success", "hooray")
                            sendEncryptedDetailsToYourServer(encryptedCardDetails)
                        }

                        override fun failure(error: RavelinError) {
                            Log.e("Card Encryption Error", error.message)
                        }
                    })
            }
        }
    }
}

public class ShopApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        // Create instance referencing the application.
        // This can be done anywhere if the application does not extend Application
        RavelinSDK.Companion.createInstance(this, "api_key_123456789", new RavelinCallback<RavelinSDK>() {
            @Override
            public void success(RavelinSDK result) {
                Log.e("Ravelin Setup Success", "hooray");
            }

            @Override
            public void failure(@NotNull RavelinError error) {
                Log.e("Ravelin Setup Error", error.getMessage());
            }
        });
    }
}


public class ShopActivity extends AppCompatActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        final String customerId = "1234"; // get customerId from your login process

        final RavelinSDK ravelin = RavelinSDK.Companion.getSharedInstance(new RavelinCallback<RavelinSDK>() {
            @Override
            public void success(RavelinSDK result) {
                result.setCustomerId(customerId); // set customer id either directly or via trackLogin method
                // this id will then be sent with all subsequent tracking events
                result.setOrderId("your own order ID"); // set order id to your own order reference
                result.trackPage("Shopping Page");
            }

            @Override
            public void failure(RavelinError error) {
                Log.e("Ravelin Setup Error", error.getMessage());
            }
        });
        final TextView cardNumberTextView = findViewById(R.id.pan);
        final TextView expirationMonthTextView = findViewById(R.id.expiration_month);
        final TextView expirationYearTextView = findViewById(R.id.expiration_year);
        final TextView nameOnCardTextView = findViewById(R.id.name_on_card);

        findViewById(R.id.payButton).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String pan = cardNumberTextView.getText().toString();
                String month = expirationMonthTextView.getText().toString();
                String year = expirationYearTextView.getText().toString();
                String name = nameOnCardTextView.getText().toString();


                CardDetails cardDetails = new CardDetails(pan, month, year, name);

                if (ravelin != null) {
                    ravelin.encryptCard(cardDetails, "RSA-KEY", new RavelinCallback<EncryptedCard>() {
                        @Override
                        public void success(EncryptedCard result) {
                            Log.e("Card Encryption Success", "hooray");
                            sendEncryptedDetailsToYourServer(encryptedCardDetails);
                        }

                        @Override
                        public void failure(@NotNull RavelinError error) {
                            Log.e("Card Encryption Error", error.getMessage());
                        }
                    });
                }
            }
        });
    }
}

/* Server-side */

var card = JSON.parse(request.params['ravelinCipherText']);
card.methodType = 'paymentMethodCipher';

var action = request('https://pci.ravelin.com/v2/checkout?score=true', {
    // ...
    'paymentMethod': card,
});

/**
 * Method for creating a singleton instance of the object that holds required methods for
 * communicating with Ravelin APIs. The created object can be accessed by a call to
 * [getSharedInstance]. In order to create the object the API key must be provided.
 *
 * If called a second time, the parameters are ignored and the initial instance is returned, unless a call
 * to [cleanup] is made between the two calls.
 *
 * @param application - The Android Application class that this instance is attached to
 * @param apiKey - The Ravelin public API key.
 * @param appVersion - Optional. Version of the application.
 * @param myDeviceId - Optional. User device id. When set, it will be used as the device id.
 *                     Instead of the SDK generated device id, even when the SDK
 *                     is first initialised with its own device id.
 * @param callback - Optional. callback.
 * @return - Create a new instance of the RavelinSDK. If this is called a second time, no
 *           new instance is created.
 */
@JvmOverloads
@Synchronized
fun createInstance(
    application: Application,
    apiKey: String,
    appVersion: String? = null,
    myDeviceId: String? = null,
    callback: RavelinCallback<RavelinSDK>? = null
): RavelinSDK?

/**
* Method for accessing the Ravelin object for communicating with its APIs.
*
* Only to be called after the Ravelin SDK has been first initialised using the API key,
* otherwise, the [RavelinCallback.failure] callback method is triggered.
*
* @param callback - An optional callback that is responsible to warn
*                 whether the RavelinSDK instance could be retrieved successfully or not.
* @return - An instance of a previously created RavelinSDK, null if it is not existent.
*/
@JvmOverloads
fun getSharedInstance(callback: RavelinCallback<RavelinSDK>? = null): RavelinSDK?

/**
 * cleaning the SDK instance and its resources.
 * Note: This function should be called if additional interactions with the SDK are not
 * expected and it can be garbage collected.
 *
 * @param callback a [RavelinCallback] of type [String] to indicate the function status
 * back to the caller.
 */
@JvmOverloads
@JvmStatic
fun cleanup(callback: RavelinCallback<String>? = null): Unit?

/**
* Property to access the unique identifier that represents user's device. The property has a
* private setter and hence can't be set externally. If the deviceId failed to be generated, calling
* this property should throw an [UninitializedPropertyAccessException] exception.
*
* @return the device id [String?]
*/
@get:Throws(UninitializedPropertyAccessException::class)
var deviceId: String? = null

ravelin.deviceId

ravelin.getDeviceId();

/**
 * Notify Ravelin of the device fingerprint. This function creates a coroutine and runs
 * asynchronously.
 *
 * @param callback - Optional callback for the API response of type [RavelinRequestCallback].
 */
@JvmOverloads
fun trackFingerprint(callback: RavelinRequestCallback? = null): Job?

/**
 * Notify Ravelin of a new page being shown.
 *
 * @param pageTitle - The title of the current screen.
 * @param payload - Additional data to be sent to Ravelin. [Properties] is a type alias of 
 *                  [LinkedHashMap<String, Any?>?].
 * @param callback - Optional callback for the API responses.
 *
 */
@JvmOverloads
fun trackPage(
    pageTitle: String,
    payload: Properties? = null,
    callback: RavelinRequestCallback? = null
)

 /**
 * Notify Ravelin of a new search being performed.
 *
 * @param pageTitle - The title of the current screen.
 * @param searchValue - Optional string that was used to perform a search. 
 * @param callback - Optional callback for the API responses.
 *
 */
@JvmOverloads
fun trackSearch(
    pageTitle: String,
    searchValue: String? = null,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin of an option being selected.
 *
 * @param pageTitle - The title of the current screen.  
 * @param option - Optional selected item definition.
 *                 Example: {colour, size, date, time, seat, ticketType}
 * @param optionValue - Optional value of the informed option.
 *                      Example: {blue, M, 14, first class}
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackSelectOption(
    pageTitle: String,
    option: String? = null,
    optionValue: String? = null,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin of a new cart addition.
 *
 * @param pageTitle - The title of the current page.
 * @param itemName - Optional. The name of the item added to the cart.
 * @param quantity - Optional. The amount of the items that were added.
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackAddToCart(
    pageTitle: String,
    itemName: String? = null,
    quantity: Int? = 0,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin of a new cart removal.
 *
 * @param pageTitle - The name of the current screen.
 * @param itemName - Optional. The name of the item removed to the cart.
 * @param quantity - Optional. The amount of the items that were removed.
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackRemoveFromCart(
    pageTitle: String,
    itemName: String? = null,
    quantity: Int? = 0,
    callback: RavelinRequestCallback? = null
)

 /**
 * Notify Ravelin of a new item added to users wishlist.
 *
 * @param pageTitle - The page where the item was added to a wishlist.
 * @param itemName - Optional. The name of the item added to a wishlist.
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackAddToWishlist(
    pageTitle: String,
    itemName: String? = null,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin of a item removed from users wishlist.
 *
 * @param pageTitle - The page where the item was removed from a wishlist.
 * @param itemName - Optional. The name of the item removed from a wishlist.
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackRemoveFromWishlist(
    pageTitle: String,
    itemName: String? = null,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin about a change in the application language.
 *
 * @param pageTitle - The page where the new language was set.
 * @param language - An ISO-639-1 representation of the new language.
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackLanguageChange(
    pageTitle: String,
    language: String?,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin about a change in the application currency.
 *
 * @param pageTitle - The page where the new currency was set.
 * @param currency - An ISO-4217 representation of the new currency.
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackCurrencyChange(
    pageTitle: String,
    currency: String?,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin that a user interacts with product contents. This interaction can be
 * plays a video, expands a photo, expands product details, clicks a link in the page, etc.
 * The call can optionally include the content type that the user interacted with.
 *
 * @param pageTitle - The page where the content was seen.
 * @param contentType - Optional. The type of content that was interacted to.
 *                      Examples: {video, photo, product description, delivery options}
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackViewContent(
    pageTitle: String,
    contentType: String? = null,
    callback: RavelinRequestCallback? = null
)

/**
 * Track a Click (customer action) Event.
 *
 * @param eventType - The type of triggered event
 * @param pageTitle - Optional. The screen in which the click event occurred.
 * @param payload - Optional object to be serialized and transmitted with the event. 
 *                  [Properties] is a type alias of [LinkedHashMap<String, Any?>?].
 * @param callback - Optional callback for the API request communication.
 */
@JvmOverloads
fun trackEvent(
    eventType: String,
    pageTitle: String? = null,
    payload: Properties? = null,
    callback: RavelinRequestCallback? = null
)

/**
 * Notify Ravelin of a successful login.
 *
 * @param customerId - The Customer identifier as a String
 * @param pageTitle - Optional. The screen where the login occurred.
 * @param payload - Optional. Additional data to be sent to Ravelin.
 *                 [Properties] is a type alias of [LinkedHashMap<String, Any?>?].
 * @param callback - Optional callback for the API responses.
 *
 */
@JvmOverloads
fun trackLogIn(
    customerId: String,
    pageTitle: String? = null,
    payload: Properties? = null,
    callback: RavelinRequestCallback? = null
)

 /**
 * Notify Ravelin of a logout and clears [sessionId].
 *
 * @param pageTitle - Optional. The page where the logout occurred
 * @param payload - Optional. Additional data to be sent to Ravelin.
 *                  [Properties] is a type alias of [LinkedHashMap<String, Any?>?].
 * @param callback - Optional callback for the API responses.
 */
@JvmOverloads
fun trackLogOut(
    pageTitle: String? = null,
    payload: Properties? = null,
    callback: RavelinRequestCallback? = null
)

/**
 * Track a paste event with the content tracked.
 *
 * @param pageTitle - Optional. The screen where the paste event occurred.
 * @param value - Pasted text string.
 * @param callback - Optional callback for the API request.
 *
 */
@JvmOverloads
fun trackPaste(
    pageTitle: String? = null,
    value: String,
    callback: RavelinRequestCallback? = null
)

/**
* Your chosen customer ID
*
* @return the customer ID [String?].
*/
var customerId: String? = null

ravelin.customerId

ravelin.customerId = "cust-1"

ravelin.getCustomerId();

ravelin.setCustomerId("cust-1");

/**
 * A temporary customer ID that will always be non-blank. Setting to a null, blank or empty value will
 * generate a new temporary customer ID.
 * 
 * @return the temporary customer ID [String?].
 */
var tempCustomerId: String? = null

ravelin.tempCustomerId

ravelin.tempCustomerId = "temp-1"

ravelin.getTempCustomerId();

ravelin.setTempCustomerId("temp-1");

/**
 * The ID for this specific order.
 *
 * @return the order ID [String?].
 */
var orderId: String? = null

ravelin.orderId

ravelin.orderId = "930393-BBB"

ravelin.getOrderId();

ravelin.setOrderId("930393-BBB");

/**
 * Encrypt provided [CardDetails] ready to be sent to Ravelin.
 *
 * @param cardDetails the plain text [CardDetails] to be encrypted
 * @param callback to handle null-safe results or handle errors
 * @return - An encrypted card of type [EncryptedCard?] or null if an error occurred during
 *           encryption.
 */
@Suppress("unused")
@JvmOverloads
@RequiresApi(Build.VERSION_CODES.LOLLIPOP_MR1)
fun encryptCard(
    cardDetails: CardDetails,
    rsaKey: String,
    callback: EncryptCallback<EncryptedCard>? = null
): EncryptedCard?

internal class BrowserViewModel : ViewModel() {
    private val cookie = MutableStateFlow(EMPTY_STRING)
    val safeCookie = cookie.asStateFlow()
        
    fun fetchCookieContent() = viewModelScope.launch(Dispatchers.Default) {
        val deviceId = RavelinSDK.getSharedInstance()?.deviceId
        cookie.updateAndGet { "$COOKIE_NAME=$deviceId" }
    }

    companion object {
        private const val COOKIE_NAME = "ravelinDeviceId"
        private const val EMPTY_STRING = ""
    }
}

private const val HOST_NAME = "https://www.yourhostname.org/"

@Composable
internal fun Browser(
    modifier: Modifier,
    myUrl: String = HOST_NAME,
    viewModel: BrowserViewModel?
) {
    
    var webView: WebView? = null
    val cookie = viewModel?.safeCookie?.collectAsStateWithLifecycle(EMPTY_STRING)?.value
    val cookiesManager = CookieManager.getInstance()
    
    // The following if-statement is important to make sure that the WebView is created when the cookie 
    // state is updated as the factory lambda is not a recomposition point.
    if (!cookie.isNullOrEmpty()) {
        AndroidView(
            modifier = modifier,
            factory = { context ->
                WebView(context).apply {
                    layoutParams = ViewGroup.LayoutParams(
                        ViewGroup.LayoutParams.MATCH_PARENT,
                        ViewGroup.LayoutParams.MATCH_PARENT
                    )
                    webViewClient = object : WebViewClient() {
                        override fun onPageStarted(
                            view: WebView?,
                            url: String?,
                            favicon: Bitmap?
                        ) {
                            println("Cookie = ${cookiesManager.getCookie(url)}")

                            super.onPageStarted(
                                view,
                                url,
                                favicon
                            )
                        }
                    }
                    webView = this
                    cookiesManager.setCookie(
                        myUrl,
                        cookie
                    )

                    loadUrl(myUrl)
                }
            })
    }

    LaunchedEffect(true) {
        viewModel?.fetchCookieContent()
    }
}