### Start Chat

Source: https://github.com/verloop/android-sdk/wiki/Migration-from-1.0.8-to-1.1.0-and-above

Initiate the Verloop chat interface using the verloop.showChat() method.

```java
verloop.showChat()
```

--------------------------------

### Initialize Verloop SDK with Minimal Configuration

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

For anonymous users or when only a client ID is available, initialize the Verloop SDK with a minimal configuration.

```kotlin
val config = VerloopConfig.Builder()("YOUR-CLIENT-ID").build()
```

--------------------------------

### Launch Verloop Chat UI

Source: https://context7.com/verloop/android-sdk/llms.txt

Initialize Verloop with an Activity Context and VerloopConfig, then call showChat() to launch the chat UI. An anonymous user ID is assigned if none is provided.

```kotlin
import io.verloop.sdk.Verloop
import io.verloop.sdk.VerloopConfig

class MainActivity : AppCompatActivity() {

    private var verloop: Verloop? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val config = VerloopConfig.Builder()
            .clientId("acme")
            .userId("user-42")
            .build()

        verloop = Verloop(this, config)

        findViewById<Button>(R.id.btnSupport).setOnClickListener {
            verloop?.showChat()   // Launches VerloopActivity with the configured session
        }
    }
}
```

--------------------------------

### Verloop.showChat() - Launch the chat UI

Source: https://context7.com/verloop/android-sdk/llms.txt

Initiate the Verloop chat interface by calling `showChat()` on a `Verloop` instance, which requires an Activity Context and a VerloopConfig object.

```APIDOC
## Verloop.showChat()

### Description
`Verloop` accepts an Activity `Context` and a `VerloopConfig`. Calling `showChat()` starts `VerloopActivity`, automatically assigning a persistent anonymous user ID if none was provided.

### Usage
```kotlin
import io.verloop.sdk.Verloop
import io.verloop.sdk.VerloopConfig

class MainActivity : AppCompatActivity() {

    private var verloop: Verloop? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val config = VerloopConfig.Builder()
            .clientId("acme")
            .userId("user-42")
            .build()

        verloop = Verloop(this, config)

        findViewById<Button>(R.id.btnSupport).setOnClickListener {
            verloop?.showChat()   // Launches VerloopActivity with the configured session
        }
    }
}
```
```

--------------------------------

### Initialize Verloop SDK with Configuration

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Initialize the Verloop SDK by creating a VerloopConfig object with essential details like client ID, user ID, and optional parameters for FCM token, recipe ID, user information, and staging environment.

```kotlin
// Exhaustive list of values which you can put while creating config
var config = VerloopConfig.Builder()
    .clientId("CLIENT_ID")              // Required: this would be your account name associated with verloop. eg: <client_id>.verloop.io
    .userId("USER_ID")                  // If user is logged in, and if you want to associate older chats, else, skip this for anonymous user 
    .fcmToken("FCMTOKEN_FOR_DEVICE")    // If you wish to get notifications, else, skip this
    .recipeId("RECIPE_ID")              // In case you want to use default recipe, skip this
    .userName("USER_NAME")              // If guest name variable is a part of the recipe, or the value is not required, skip this
    .userEmail("USER_EMAIL")            // If email variable is a part of the recipe, or the value is not required, skip this
    .userPhone("USER_PHONE")            // If phone variable is a part of the recipe, or the value is not required, skip this
    .isStaging(false)                   // Keep this as true if you want to access <client_id>.stage.verloop.io account. If the account doesn't exist, keep it as false or skip it
    .closeExistingChat(false)           // Close the existing chat if exist and start a new conversation
    .fields(customFields)               // These are predefined variables added on room level or user level
    .overrideHeaderLayout(false)        // Use toolbar_verloop.xml from parent project to set custom header. Can't use along with headerConfig
    .headerConfig(headerConfig)         // Configuration to customize toolbar. Can't use along with overrideHeaderLayout
    .allowFileDownload(true)            // This will allow visitors to download the attachments. If this is false, download button will not be visible on the attachment
    .build()                            // this would build the final config object which is later used by Verloop object to star the chat

val verloop = Verloop(this, config)     // `this` here refers to an activity context.
```

--------------------------------

### Build VerloopConfig with Custom Fields and Header

Source: https://context7.com/verloop/android-sdk/llms.txt

Use VerloopConfig.Builder to configure chat session parameters, including custom fields and programmatic header customization. Handle potential VerloopExceptions during build.

```kotlin
import io.verloop.sdk.VerloopConfig
import io.verloop.sdk.VerloopException
import io.verloop.sdk.model.HeaderConfig
import io.verloop.sdk.enum.Position

// Full configuration example
try {
    val customFields = ArrayList<VerloopConfig.CustomField>().apply {
        add(VerloopConfig.CustomField("plan_type", "premium", VerloopConfig.Scope.USER))
        add(VerloopConfig.CustomField("order_id", "ORD-9921", VerloopConfig.Scope.ROOM))
    }

    val headerConfig = HeaderConfig.Builder()
        .brandLogo("https://example.com/logo.png")
        .title("Acme Support")
        .titleColor("#FFFFFF")
        .titlePosition(Position.LEFT)
        .titleFontSize(18.0f)
        .subtitle("We reply in minutes")
        .subtitleColor("#FFFFFF")
        .subtitlePosition(Position.LEFT)
        .subtitleFontSize(12.0f)
        .backgroundColor("#0055FF")
        .build()

    val config = VerloopConfig.Builder()
        .clientId("acme")                      // Required: acme.verloop.io
        .userId("user-42")                     // Omit for anonymous users
        .fcmToken(fcmToken)                    // For push notifications
        .recipeId("onboarding-flow")           // Override default recipe
        .userName("Jane Doe")
        .userEmail("jane@example.com")
        .userPhone("+919876543210")
        .department("billing")
        .closeExistingChat(false)              // true = force-start a new conversation
        .allowFileDownload(true)               // Show download button on attachments
        .openMenuWidgetOnStart(false)
        .overrideHeaderLayout(false)           // true = use toolbar_verloop.xml from host app
        .headerConfig(headerConfig)            // Programmatic toolbar customization
        .fields(customFields)
        .build()
} catch (e: VerloopException) {
    Log.e("Verloop", "Config error: ${e.message}")
}
```

```kotlin
// Minimal anonymous-user configuration
val minimalConfig = VerloopConfig.Builder()
    .clientId("acme")
    .build()
```

--------------------------------

### VerloopConfig.Builder - Build a chat session configuration

Source: https://context7.com/verloop/android-sdk/llms.txt

Use VerloopConfig.Builder to create a configuration object for chat sessions. The clientId is required, while other fields like userId, fcmToken, and custom fields are optional.

```APIDOC
## VerloopConfig.Builder

### Description
`VerloopConfig.Builder` is the entry point for all session configuration. `clientId` (your Verloop account subdomain) is the only required field; all other fields are optional. Calling `build()` validates inputs and throws `VerloopException` if `clientId` is null or empty.

### Usage
```kotlin
import io.verloop.sdk.VerloopConfig
import io.verloop.sdk.VerloopException
import io.verloop.sdk.model.HeaderConfig
import io.verloop.sdk.enum.Position

// Full configuration example
try {
    val customFields = ArrayList<VerloopConfig.CustomField>().apply {
        add(VerloopConfig.CustomField("plan_type", "premium", VerloopConfig.Scope.USER))
        add(VerloopConfig.CustomField("order_id", "ORD-9921", VerloopConfig.Scope.ROOM))
    }

    val headerConfig = HeaderConfig.Builder()
        .brandLogo("https://example.com/logo.png")
        .title("Acme Support")
        .titleColor("#FFFFFF")
        .titlePosition(Position.LEFT)
        .titleFontSize(18.0f)
        .subtitle("We reply in minutes")
        .subtitleColor("#FFFFFF")
        .subtitlePosition(Position.LEFT)
        .subtitleFontSize(12.0f)
        .backgroundColor("#0055FF")
        .build()

    val config = VerloopConfig.Builder()
        .clientId("acme")                      // Required: acme.verloop.io
        .userId("user-42")                     // Omit for anonymous users
        .fcmToken(fcmToken)                    // For push notifications
        .recipeId("onboarding-flow")           // Override default recipe
        .userName("Jane Doe")
        .userEmail("jane@example.com")
        .userPhone("+919876543210")
        .department("billing")
        .closeExistingChat(false)              // true = force-start a new conversation
        .allowFileDownload(true)               // Show download button on attachments
        .openMenuWidgetOnStart(false)
        .overrideHeaderLayout(false)           // true = use toolbar_verloop.xml from host app
        .headerConfig(headerConfig)            // Programmatic toolbar customization
        .fields(customFields)
        .build()
} catch (e: VerloopException) {
    Log.e("Verloop", "Config error: ${e.message}")
}

// Minimal anonymous-user configuration
val minimalConfig = VerloopConfig.Builder()
    .clientId("acme")
    .build()
```
```

--------------------------------

### Configure Header with HeaderConfig

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Use HeaderConfig to customize the toolbar's appearance, including brand logo, title, subtitle, and colors. Set `overrideHeaderLayout` to false when using this.

```kotlin
val headerConfig = HeaderConfig.Builder()
    .brandLogo("https://logo-url")
    .title("Verloop")
    .titleColor("#FFFFFF")
    .titlePosition(Position.LEFT)
    .titleFontSize(18.0f)
    .subtitle("Support automation")
    .subtitleColor("#FFFFFF")
    .subtitlePosition(Position.LEFT)
    .subtitleFontSize(12.0f)
    .backgroundColor("#d451db")
    .build()

val verloopConfig = VerloopConfig.Builder()
    .clientId("client_id")
    .overrideHeaderLayout(false)
    .headerConfig(headerConfig)
    .fields(customFields)
    .build()
```

--------------------------------

### VerloopConfig.setButtonClickListener()

Source: https://context7.com/verloop/android-sdk/llms.txt

Registers a callback to intercept user taps on quick-reply or action buttons presented by the bot. The listener receives the button's title, type (e.g., 'web_url', 'postback'), and payload for custom handling.

```APIDOC
## `VerloopConfig.setButtonClickListener()` — Intercept bot button taps

Registers a `LiveChatButtonClickListener` callback that fires whenever the user taps a quick-reply or action button rendered by the bot. Receives the button `title`, `type` (e.g. `"web_url"`, `"postback"`), and `payload`.

```kotlin
import io.verloop.sdk.LiveChatButtonClickListener
import io.verloop.sdk.VerloopConfig
import android.content.Intent
import android.net.Uri

val config = VerloopConfig.Builder().clientId("acme").build()

config.setButtonClickListener(object : LiveChatButtonClickListener {
    override fun buttonClicked(title: String?, type: String?, payload: String?) {
        when (type) {
            "web_url" -> {
                // Open URL in external browser
                try {
                    val json = JSONObject(payload)
                    val url = json.optString("url")
                    if (url.isNotEmpty()) {
                        startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
                    }
                } catch (e: JSONException) {
                    Log.e("Verloop", "Invalid payload JSON", e)
                }
            }
            "postback" -> {
                // Handle internal navigation or analytics
                Log.d("Verloop", "Button '$title' tapped with payload: $payload")
            }
        }
    }
})
```
```

--------------------------------

### Add Verloop SDK Dependency

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Add JitPack to your project's repositories and then include the Verloop SDK dependency in your app's Gradle file.

```gradle
allprojects {
    repositories {
      ... 
      maven { url 'https://jitpack.io' }
    }
  }
```

```gradle
dependencies {
          implementation 'com.github.verloop:android-sdk:1.1.21'
  }
```

--------------------------------

### Handle Notification Click to Open Chat

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Override `onCreate` and `onNewIntent` in your launcher activity to detect incoming Verloop notification intents. If a Verloop-specific extra is found, it extracts the client ID to initialize and display the chat.

```kotlin
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_test)
    // ...
    if (intent != null) {
        onNewIntent(intent)
    }
    // ...
}

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    if (intent != null && intent.extras != null && intent.extras?.containsKey("verloop") == true) {
        val json = intent.extras?.getString("verloop")
        try {
            val jsonObject = JSONObject(json)
            if (jsonObject.has("client_id")) {
                var clientId = jsonObject.getString("client_id")
                if (clientId != null) {
                    var config = VerloopConfig.Builder().clientId(clientId).build()
                    Verloop(this, config).showChat()
                }
            }
        } catch (e: JSONException) {
            Log.e(TAG, e.message.toString())
        }
    }
}
```

--------------------------------

### VerloopConfig.setUrlClickListener()

Source: https://context7.com/verloop/android-sdk/llms.txt

Registers a listener to intercept URL taps within the chat. Allows for custom handling of URLs, including deep-linking or opening in custom tabs, by suppressing the default browser behavior.

```APIDOC
## `VerloopConfig.setUrlClickListener()` — Intercept in-chat URL taps

Registers a `LiveChatUrlClickListener` that fires when the user taps any URL in the chat (from bot messages or agent messages). Set `overrideUrlClick = true` to suppress the default browser open and handle the URL entirely within the app.

```kotlin
import io.verloop.sdk.LiveChatUrlClickListener
import io.verloop.sdk.VerloopConfig

val config = VerloopConfig.Builder().clientId("acme").build()

config.setUrlClickListener(
    urlClickListener = object : LiveChatUrlClickListener {
        override fun urlClicked(url: String?) {
            if (url != null && url.startsWith("myapp://")) {
                // Deep-link into a product detail page
                val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
                startActivity(intent)
            } else {
                // Open external links in custom Chrome Tab
                CustomTabsIntent.Builder().build()
                    .launchUrl(this@MainActivity, Uri.parse(url))
            }
        }
    },
    overrideUrlClick = true   // true = suppress SDK's default browser open
)
```
```

--------------------------------

### Implement URL Click Listener

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Configure a `LiveChatUrlClickListener` to intercept URL clicks within the chat. The `overrideUrlClick` parameter determines whether the app handles the URL internally or opens it in a browser. The listener provides the clicked URL for custom handling.

```kotlin
config?.setUrlClickListener(object : LiveChatUrlClickListener {
    override fun buttonClicked(url: String?) {
        // Add the app logic for url click
    }
}, overrideUrlClick)
```

--------------------------------

### Add Verloop Android SDK Dependency

Source: https://context7.com/verloop/android-sdk/llms.txt

Add the JitPack repository and the SDK dependency to your project's Gradle files. Ensure ProGuard rules are included if ProGuard is enabled.

```groovy
// project-level build.gradle
allprojects {
    repositories {
        maven { url 'https://jitpack.io' }
    }
}

// app-level build.gradle
dependencies {
    implementation 'com.github.verloop:android-sdk:1.1.21'
}
```

```proguard
-keepattributes *Annotation*
```

--------------------------------

### Programmatic Toolbar Customization with HeaderConfig

Source: https://context7.com/verloop/android-sdk/llms.txt

Use HeaderConfig.Builder to customize the chat toolbar's appearance programmatically. This requires `overrideHeaderLayout(false)` in VerloopConfig.

```kotlin
import io.verloop.sdk.model.HeaderConfig
import io.verloop.sdk.enum.Position
import io.verloop.sdk.VerloopConfig

val header = HeaderConfig.Builder()
    .brandLogo("https://cdn.example.com/support-avatar.png")
    .title("Acme Help Desk")
    .titleColor("#FFFFFF")
    .titlePosition(Position.LEFT)       // LEFT | CENTER | RIGHT
    .titleFontSize(18.0f)
    .subtitle("Typically replies in < 2 min")
    .subtitleColor("#E0E0E0")
    .subtitlePosition(Position.LEFT)
    .subtitleFontSize(13.0f)
    .backgroundColor("#1A1A2E")
    .build()

val config = VerloopConfig.Builder()
    .clientId("acme")
    .overrideHeaderLayout(false)   // Must be false when using headerConfig
    .headerConfig(header)
    .build()

Verloop(this, config).showChat()
```

--------------------------------

### Update VerloopConfig Object Creation

Source: https://github.com/verloop/android-sdk/wiki/Migration-from-1.0.8-to-1.1.0-and-above

Use the VerloopConfig.Builder pattern for creating VerloopConfig objects instead of the constructor and setters.

```java
Var verloopConfig =
   VerloopConfig.Builder()
       .clientId(“hello”)
       .userId(“UserId”)
       .build()
```

--------------------------------

### VerloopConfig.setLogEventListener()

Source: https://context7.com/verloop/android-sdk/llms.txt

Subscribes to internal SDK log events. This allows developers to monitor chat widget activity, forward events to analytics, and debug issues by filtering events based on severity level.

```APIDOC
## `VerloopConfig.setLogEventListener()` — Stream internal SDK log events

Subscribes to internal analytics/log events emitted by the chat widget. The `LogLevel` filter controls the minimum severity level (`ERROR`, `WARNING`, `INFO`, `DEBUG`) that the listener receives.

```kotlin
import io.verloop.sdk.LiveLogEventListener
import io.verloop.sdk.model.LogEvent
import io.verloop.sdk.model.LogLevel
import io.verloop.sdk.VerloopConfig

val config = VerloopConfig.Builder().clientId("acme").build()

config.setLogEventListener(
    logEventListener = object : LiveLogEventListener {
        override fun logEvent(event: LogEvent) {
            // event.type    — category/name of the event
            // event.message — human-readable description
            // event.params  — optional JSONObject with extra data
            Log.d("VerloopLog", "[${event.type}] ${event.message} | params=${event.params}")

            // Forward to your own analytics pipeline
            analytics.track(event.type, mapOf(
                "message" to event.message,
                "params"  to event.params?.toString()
            ))
        }
    },
    logLevel = LogLevel.DEBUG   // Receive all events; use WARNING/ERROR for production
)
```
```

--------------------------------

### VerloopConfig.putCustomField()

Source: https://context7.com/verloop/android-sdk/llms.txt

Attaches custom key-value metadata to either the current conversation (Scope.ROOM) or the user's profile (Scope.USER). Room-scoped fields are temporary for the current chat, while user-scoped fields persist across conversations.

```APIDOC
## `VerloopConfig.putCustomField()` — Attach custom variables to a session

Attaches key-value metadata to either the conversation (`Scope.ROOM`) or the user profile (`Scope.USER`). Room-scoped fields reset per conversation; user-scoped fields persist across conversations for the same user.

```kotlin
import io.verloop.sdk.VerloopConfig

val config = VerloopConfig.Builder()
    .clientId("acme")
    .userId("user-42")
    .build()

// Conversation-scoped: resets each new chat
config.putCustomField("cart_value", "1299.00", VerloopConfig.Scope.ROOM)
config.putCustomField("product_sku", "SKU-XYZ", VerloopConfig.Scope.ROOM)

// User-scoped: persists across conversations
config.putCustomField("subscription_tier", "gold", VerloopConfig.Scope.USER)

// Default scope (no Scope argument) — treated as room-scoped
config.putCustomField("session_page", "checkout")

// Alternatively, pass pre-built fields list via the builder
val fields = ArrayList<VerloopConfig.CustomField>().apply {
    add(VerloopConfig.CustomField("order_id", "ORD-5541", VerloopConfig.Scope.ROOM))
    add(VerloopConfig.CustomField("loyalty_points", "840", VerloopConfig.Scope.USER))
}
val configWithFields = VerloopConfig.Builder()
    .clientId("acme")
    .fields(fields)
    .build()
```
```

--------------------------------

### Intercept Bot Button Taps with VerloopConfig.setButtonClickListener()

Source: https://context7.com/verloop/android-sdk/llms.txt

Register a callback to intercept user taps on quick-reply or action buttons rendered by the bot. The callback receives the button title, type (e.g., "web_url", "postback"), and payload. Handles opening web URLs in an external browser or processing internal postback actions.

```kotlin
import io.verloop.sdk.LiveChatButtonClickListener
import io.verloop.sdk.VerloopConfig
import android.content.Intent
import android.net.Uri
import org.json.JSONException
import org.json.JSONObject
import android.util.Log

val config = VerloopConfig.Builder().clientId("acme").build()

config.setButtonClickListener(object : LiveChatButtonClickListener {
    override fun buttonClicked(title: String?, type: String?, payload: String?) {
        when (type) {
            "web_url" -> {
                // Open URL in external browser
                try {
                    val json = JSONObject(payload)
                    val url = json.optString("url")
                    if (url.isNotEmpty()) {
                        startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
                    }
                } catch (e: JSONException) {
                    Log.e("Verloop", "Invalid payload JSON", e)
                }
            }
            "postback" -> {
                // Handle internal navigation or analytics
                Log.d("Verloop", "Button '$title' tapped with payload: $payload")
            }
        }
    }
})
```

--------------------------------

### Implement Button Click Listener

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Set a `LiveChatButtonClickListener` on the Verloop configuration to handle user interactions when buttons are clicked within the chat interface. This allows you to define custom app logic based on the button's title, type, and payload.

```kotlin
config?.setButtonClickListener(object : LiveChatButtonClickListener {
    override fun buttonClicked(title: String?, type: String?, payload: String?) {
        // Add the app logic for button click
    }
})
```

--------------------------------

### Handling notification tap

Source: https://context7.com/verloop/android-sdk/llms.txt

This section describes how to handle taps on Verloop push notifications to reopen the chat. It involves overriding `onCreate` and `onNewIntent` in the launcher Activity to detect and process notification intents.

```APIDOC
## Handling notification tap — reopen chat from deep-link intent

Override `onCreate` and `onNewIntent` in the launcher Activity to detect when the user taps a Verloop push notification and automatically reopen the chat session.

```kotlin
import io.verloop.sdk.Verloop
import io.verloop.sdk.VerloopConfig
import org.json.JSONObject

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // Process notification tap on cold start
        if (intent != null) onNewIntent(intent)
    }

    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        intent?.extras?.getString("verloop")?.let {
            try {
                val obj = JSONObject(it)
                val clientId = obj.optString("client_id")
                val userId   = obj.optString("user_id")
                if (clientId.isNotEmpty()) {
                    val config = VerloopConfig.Builder()
                        .clientId(clientId)
                        .userId(userId.ifEmpty { null })
                        .build()
                    Verloop(this, config).showChat()
                }
            } catch (e: JSONException) {
                Log.e("Verloop", "Notification intent parse error: ${e.message}")
            }
        }
    }
}
```
```

--------------------------------

### Update Root build.gradle Dependencies

Source: https://github.com/verloop/android-sdk/wiki/Migration-from-1.0.8-to-1.1.0-and-above

Apply the Kotlin Android plugin and update Gradle and Google Services plugin versions in your root build.gradle file.

```gradle
apply plugin: 'kotlin-android'
```

```gradle
classpath 'com.android.tools.build:gradle:4.2.0'
```

```gradle
classpath 'com.google.gms:google-services:4.3.10'
```

--------------------------------

### Proguard Configuration for Verloop SDK

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

If you are using Proguard in your Android project, add this configuration to preserve necessary attributes.

```proguard
-keepattributes *Annotation*
```

--------------------------------

### Set Custom Fields for User (Global Scope)

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Set custom fields with `Scope.USER` to associate data with a customer globally, such as name or email, which typically do not change across conversations.

```kotlin
config.putCustomField("Test Field", "Test Value", Scope.USER)
```

--------------------------------

### Handle Notification Tap to Reopen Chat

Source: https://context7.com/verloop/android-sdk/llms.txt

Override `onCreate` and `onNewIntent` in your launcher Activity to detect taps on Verloop push notifications. This allows the chat session to be automatically reopened with the correct client and user IDs.

```kotlin
import io.verloop.sdk.Verloop
import io.verloop.sdk.VerloopConfig
import org.json.JSONObject

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // Process notification tap on cold start
        if (intent != null) onNewIntent(intent)
    }

    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        intent?.extras?.getString("verloop")?.let { json ->
            try {
                val obj = JSONObject(json)
                val clientId = obj.optString("client_id")
                val userId   = obj.optString("user_id")
                if (clientId.isNotEmpty()) {
                    val config = VerloopConfig.Builder()
                        .clientId(clientId)
                        .userId(userId.ifEmpty { null })
                        .build()
                    Verloop(this, config).showChat()
                }
            } catch (e: JSONException) {
                Log.e("Verloop", "Notification intent parse error: ${e.message}")
            }
        }
    }
}
```

--------------------------------

### Attach Custom Variables with VerloopConfig.putCustomField()

Source: https://context7.com/verloop/android-sdk/llms.txt

Attach key-value metadata to the conversation (Scope.ROOM) or user profile (Scope.USER). Room-scoped fields reset per conversation, while user-scoped fields persist across conversations for the same user. The default scope is room-scoped.

```kotlin
import io.verloop.sdk.VerloopConfig

val config = VerloopConfig.Builder()
    .clientId("acme")
    .userId("user-42")
    .build()

// Conversation-scoped: resets each new chat
config.putCustomField("cart_value", "1299.00", VerloopConfig.Scope.ROOM)
config.putCustomField("product_sku", "SKU-XYZ", VerloopConfig.Scope.ROOM)

// User-scoped: persists across conversations
config.putCustomField("subscription_tier", "gold", VerloopConfig.Scope.USER)

// Default scope (no Scope argument) — treated as room-scoped
config.putCustomField("session_page", "checkout")

// Alternatively, pass pre-built fields list via the builder
val fields = ArrayList<VerloopConfig.CustomField>().apply {
    add(VerloopConfig.CustomField("order_id", "ORD-5541", VerloopConfig.Scope.ROOM))
    add(VerloopConfig.CustomField("loyalty_points", "840", VerloopConfig.Scope.USER))
}
val configWithFields = VerloopConfig.Builder()
    .clientId("acme")
    .fields(fields)
    .build()
```

--------------------------------

### Stream Internal SDK Log Events

Source: https://context7.com/verloop/android-sdk/llms.txt

Subscribe to internal analytics and log events emitted by the Verloop chat widget. Filter events by `LogLevel` (DEBUG, INFO, WARNING, ERROR) and forward them to your own analytics pipeline.

```kotlin
import io.verloop.sdk.LiveLogEventListener
import io.verloop.sdk.model.LogEvent
import io.verloop.sdk.model.LogLevel
import io.verloop.sdk.VerloopConfig

val config = VerloopConfig.Builder().clientId("acme").build()

config.setLogEventListener(
    logEventListener = object : LiveLogEventListener {
        override fun logEvent(event: LogEvent) {
            // event.type    — category/name of the event
            // event.message — human-readable description
            // event.params  — optional JSONObject with extra data
            Log.d("VerloopLog", "[${event.type}] ${event.message} | params=${event.params}")

            // Forward to your own analytics pipeline
            analytics.track(event.type, mapOf(
                "message" to event.message,
                "params"  to event.params?.toString()
            ))
        }
    },
    logLevel = LogLevel.DEBUG   // Receive all events; use WARNING/ERROR for production
)
```

--------------------------------

### Add FCM Token for Notifications

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Append the FCM token to the VerloopConfig during initialization to enable push notifications. This must be done before building the config object.

```kotlin
config.fcmToken("FCMTOKEN-FOR-DEVICE").build()
```

--------------------------------

### Update User Properties

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Modify user properties such as name, email, and phone directly on the VerloopConfig object after initialization.

```kotlin
config.userName("Name").build()
config.userEmail("Email").build()
config.userPhone("Phone").build()
```

--------------------------------

### Verloop.closeChat()

Source: https://context7.com/verloop/android-sdk/llms.txt

Programmatically closes the chat screen. If the chat activity is not fully initialized, it schedules the closure for when the widget becomes ready. This is useful for dismissing the chat from outside the UI.

```APIDOC
## `Verloop.closeChat()` — Programmatically close the chat screen

Closes the currently open chat activity from outside the chat UI. If the activity is not yet fully initialized, sets a pending flag so the close happens once the widget is ready.

```kotlin
import io.verloop.sdk.Verloop

// Example: close chat when user navigates away from a specific flow
class CheckoutActivity : AppCompatActivity() {

    private lateinit var verloop: Verloop

    override fun onStop() {
        super.onStop()
        verloop.closeChat()   // Dismiss chat if still open when leaving checkout
    }
}
```
```

--------------------------------

### Set Custom Fields for Conversation

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Add custom fields to a conversation with `Scope.ROOM` to associate data with a specific chat session. These values can be updated for new conversations.

```kotlin
config.putCustomField("Test Field", "Test Value")
```

```kotlin
config.putCustomField("Test Field", "Test Value", Scope.ROOM)
```

--------------------------------

### Intercept URL Taps in Chat

Source: https://context7.com/verloop/android-sdk/llms.txt

Register a listener to intercept URL taps within the chat. Set `overrideUrlClick` to `true` to handle URLs entirely within your app, such as deep-linking or opening custom tabs.

```kotlin
import io.verloop.sdk.LiveChatUrlClickListener
import io.verloop.sdk.VerloopConfig

val config = VerloopConfig.Builder().clientId("acme").build()

config.setUrlClickListener(
    urlClickListener = object : LiveChatUrlClickListener {
        override fun urlClicked(url: String?) {
            if (url != null && url.startsWith("myapp://")) {
                // Deep-link into a product detail page
                val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
                startActivity(intent)
            } else {
                // Open external links in custom Chrome Tab
                CustomTabsIntent.Builder().build()
                    .launchUrl(this@MainActivity, Uri.parse(url))
            }
        }
    },
    overrideUrlClick = true   // true = suppress SDK's default browser open
)
```

--------------------------------

### Programmatically Close Chat with Verloop.closeChat()

Source: https://context7.com/verloop/android-sdk/llms.txt

Use this method to close the currently open chat activity from outside the chat UI. If the activity is not yet fully initialized, it sets a pending flag to close the widget once ready.

```kotlin
import io.verloop.sdk.Verloop

// Example: close chat when user navigates away from a specific flow
class CheckoutActivity : AppCompatActivity() {

    private lateinit var verloop: Verloop

    override fun onStop() {
        super.onStop()
        verloop.closeChat()   // Dismiss chat if still open when leaving checkout
    }
}
```

--------------------------------

### End User Session with Verloop.logout()

Source: https://context7.com/verloop/android-sdk/llms.txt

Call this method to clear the locally persisted user ID and unregister the device FCM token. It's safe to call even when the chat UI is not visible.

```kotlin
import io.verloop.sdk.Verloop

class ProfileActivity : AppCompatActivity() {

    private lateinit var verloop: Verloop

    fun onLogoutButtonClick() {
        // Clear Verloop session alongside your own auth logout
        verloop.logout()
        // Continue with host-app sign-out logic...
        authManager.signOut()
        startActivity(Intent(this, LoginActivity::class.java))
    }
}
```

--------------------------------

### Logout User Session

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Call the `verloop.logout()` method when a user logs out of your application to properly end their session with the Verloop service.

```kotlin
verloop.logout()
```

--------------------------------

### Update App build.gradle SDK and Firebase Dependencies

Source: https://github.com/verloop/android-sdk/wiki/Migration-from-1.0.8-to-1.1.0-and-above

Modify your app's build.gradle to set compile and target SDK versions to 33, and update the Firebase Messaging and Analytics dependencies.

```gradle
compileSdkVersion 33
targetSdkVersion 33
```

```gradle
implementation 'com.google.firebase:firebase-messaging-ktx:23.0.0'
implementation platform('com.google.firebase:firebase-bom:29.0.3')
implementation 'com.google.firebase:firebase-analytics-ktx'
```

--------------------------------

### VerloopNotification.showNotification()

Source: https://context7.com/verloop/android-sdk/llms.txt

Displays a system notification for incoming FCM push messages if the chat UI is not currently visible. This method is intended to be called from `FirebaseMessagingService.onMessageReceived()`.

```APIDOC
## `VerloopNotification.showNotification()` — Display FCM push notifications

Called from `FirebaseMessagingService.onMessageReceived()`, this method checks whether the incoming FCM message belongs to Verloop (via the `"verloop"` data key) and shows a system notification only when the chat UI is not currently visible. Returns `true` if a notification was posted.

```kotlin
import io.verloop.sdk.VerloopNotification
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage

class MyFirebaseMessagingService : FirebaseMessagingService() {

    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        val wasVerloopNotification = VerloopNotification.showNotification(
            context      = this,
            smallIcon    = R.drawable.ic_notification,   // Your notification icon drawable
            data         = remoteMessage.data,
            channelName  = "Acme Support Chat"           // Android O+ notification channel name
        )

        if (!wasVerloopNotification) {
            // Handle non-Verloop notifications here
        }
    }
}
```
```

--------------------------------

### Handle Verloop Notifications in FirebaseMessagingService

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Integrate Verloop's notification handling into your `FirebaseMessagingService` by calling `VerloopNotification.showNotification`. This method processes incoming Verloop messages and displays them using a specified icon and notification channel.

```kotlin
@Override
fun onMessageReceived(remoteMessage: RemoteMessage) {
    // set a drawable to use as icon for notifications
    val icon = R.drawable.notification_image

    // Notifications will be auto-ignored if it's not from Verloop. Default notification channel name will be "Verloop Chat Message"
    VerloopNotification.showNotification(
        this,
        icon,
        remoteMessage.getData(),
        "Your Notification Channel Name"
    )

    // Do anything else with your message.
}
```

--------------------------------

### Manually Override Recipe ID

Source: https://github.com/verloop/android-sdk/blob/master/Readme.md

Override the default recipe ID during a conversation by calling the `recipeId()` method on the VerloopConfig object.

```kotlin
config.recipeId("<Recipe ID>").build()
```

--------------------------------

### Update FCM Token Retrieval API

Source: https://github.com/verloop/android-sdk/wiki/Migration-from-1.0.8-to-1.1.0-and-above

Replace the deprecated FirebaseInstanceId.getInstance() with FirebaseMessaging.getInstance() for retrieving FCM tokens.

```java
FirebaseMessaging.getInstance()
```

--------------------------------

### Display FCM Push Notifications

Source: https://context7.com/verloop/android-sdk/llms.txt

Implement `onMessageReceived` in your `FirebaseMessagingService` to display Verloop push notifications. This method checks for Verloop data and shows a system notification only when the chat UI is not visible.

```kotlin
import io.verloop.sdk.VerloopNotification
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage

class MyFirebaseMessagingService : FirebaseMessagingService() {

    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        val wasVerloopNotification = VerloopNotification.showNotification(
            context      = this,
            smallIcon    = R.drawable.ic_notification,   // Your notification icon drawable
            data         = remoteMessage.data,
            channelName  = "Acme Support Chat"           // Android O+ notification channel name
        )

        if (!wasVerloopNotification) {
            // Handle non-Verloop notifications here
        }
    }
}
```

--------------------------------

### Verloop.logout()

Source: https://context7.com/verloop/android-sdk/llms.txt

Ends the current user session by clearing local user data and unregistering the device's FCM token from Verloop notifications. This operation is safe to call regardless of the chat UI's visibility.

```APIDOC
## `Verloop.logout()` — End the user session

Clears the locally persisted user ID and enqueues a background WorkManager task to unregister the device FCM token from Verloop's notification subscription. Safe to call even when the chat UI is not visible.

```kotlin
import io.verloop.sdk.Verloop

class ProfileActivity : AppCompatActivity() {

    private lateinit var verloop: Verloop

    fun onLogoutButtonClick() {
        // Clear Verloop session alongside your own auth logout
        verloop.logout()
        // Continue with host-app sign-out logic...
        authManager.signOut()
        startActivity(Intent(this, LoginActivity::class.java))
    }
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.