Android SDK (Kotlin)

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}

dependencies {
    implementation 'com.conferbot:android-sdk:1.0.0'
}

dependencies {
    implementation("com.conferbot:android-sdk:1.0.0")
}

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

import android.app.Application
import com.conferbot.sdk.core.Conferbot
import com.conferbot.sdk.models.ConferBotConfig

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        Conferbot.initialize(
            context = this,
            apiKey = "conf_test_key",   // any conf_ placeholder works
            botId = "YOUR_BOT_ID",      // the real credential
            config = ConferBotConfig(
                enableNotifications = true,
                enableOfflineMode = true
            )
        )
    }
}

<application
    android:name=".MyApplication"
    ...>
</application>

fun initialize(
    context: Context,
    apiKey: String,
    botId: String,
    config: ConferBotConfig = ConferBotConfig(),
    customization: ConferBotCustomization? = null,
    user: ConferBotUser? = null,
    baseUrl: String? = null,
    socketUrl: String? = null,
    paginationConfig: PaginationConfig = PaginationConfig()
)

import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import com.conferbot.sdk.ui.compose.ConferBotWidget
import com.conferbot.sdk.ui.compose.ConferBotWidgetScope

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyAppTheme {
                // Option A: wrap your app content
                ConferBotWidgetScope {
                    MyMainScreen()
                }
            }
        }
    }
}

// Option B: place it yourself in a Box
@Composable
fun MyApp() {
    Box(Modifier.fillMaxSize()) {
        MyMainScreen()
        ConferBotWidget()
    }
}

import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.conferbot.sdk.ui.compose.ConferBotWidgetConfig
import com.conferbot.sdk.ui.compose.WidgetPosition

ConferBotWidget(
    config = ConferBotWidgetConfig(
        position = WidgetPosition.BOTTOM_RIGHT,  // or BOTTOM_LEFT
        size = 50.dp,
        offsetX = 10.dp,
        offsetY = 10.dp,
        backgroundColor = Color(0xFF1B55F3),
        showUnreadBadge = true,
        borderRadius = null                      // null = fully circular
    )
)

import com.conferbot.sdk.core.Conferbot

Conferbot.openChat(this)

import androidx.compose.runtime.*
import com.conferbot.sdk.ui.compose.ConferBotChatScreen

@Composable
fun SupportScreen() {
    var showChat by remember { mutableStateOf(false) }

    Button(onClick = { showChat = true }) {
        Text("Chat with us")
    }

    if (showChat) {
        ConferBotChatScreen(
            onDismiss = { showChat = false }
        )
    }
}

import com.conferbot.sdk.ui.compose.ConferBotChatView
import com.conferbot.sdk.ui.compose.ConferBotThemedChatScreen

ConferBotChatView(theme = myTheme)                       // single fixed theme
ConferBotChatView(lightTheme = myLight, darkTheme = myDark, useDarkTheme = null)
ConferBotThemedChatScreen(onDismiss = { /* ... */ })     // modal with dismiss

import androidx.compose.runtime.collectAsState
import com.conferbot.sdk.core.Conferbot

@Composable
fun CustomChat() {
    val messages by Conferbot.record.collectAsState()
    val isAgentTyping by Conferbot.isAgentTyping.collectAsState()
    val isConnected by Conferbot.isConnected.collectAsState()
    val isOnline by Conferbot.isOnline.collectAsState()

    Column {
        if (!isOnline) OfflineChip()
        LazyColumn(Modifier.weight(1f)) {
            items(messages) { item -> MyBubble(item) }
            if (isAgentTyping) item { MyTypingDots() }
        }
        MyInput(onSend = { Conferbot.sendMessage(it) })
    }
}

Conferbot.sendMessage("Hello from my custom UI")
Conferbot.sendTypingStatus(true)
Conferbot.initiateHandover(message = "I need help with billing")
Conferbot.endChat()
Conferbot.resetUnreadCount()

// Pagination: when the user scrolls near the top
if (Conferbot.hasMoreMessages()) {
    Conferbot.loadMoreMessages()
}

import com.conferbot.sdk.models.ConferBotUser

Conferbot.identify(
    ConferBotUser(
        id = "user-123",              // required
        name = "Jane Doe",
        email = "[email protected]",
        phone = "+1234567890",
        metadata = mapOf(
            "plan" to "premium",
            "signupDate" to "2024-01-15"
        )
    )
)

fun onLoggedIn(user: MyUser) {
    Conferbot.identify(ConferBotUser(id = user.id, name = user.name, email = user.email))
}

fun onLoggedOut() {
    Conferbot.clearHistory()        // drop the previous user's local conversation
    Conferbot.unregisterPushToken() // stop routing pushes to this device
}

import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.conferbot.sdk.ui.compose.ConferBotChatView
import com.conferbot.sdk.ui.theme.ConferbotThemeBuilder
import com.conferbot.sdk.ui.theme.LightTheme

val brandTheme = ConferbotThemeBuilder.create()
    .baseTheme(LightTheme)                 // start from the SDK light theme
    .name("Brand")
    .primaryColor(Color(0xFF6366F1))
    .headerColors(background = Color(0xFF6366F1), text = Color.White)
    .botBubbleColors(background = Color(0xFFF3F4F6), text = Color(0xFF111827))
    .userBubbleColors(background = Color(0xFF6366F1), text = Color.White)
    .inputColors(
        background = Color.White,
        text = Color(0xFF111827),
        border = Color(0xFFE5E7EB)
    )
    .bubbleRadius(16.dp)
    .messageSize(15.sp)
    .build()

// Single theme
ConferBotChatView(theme = brandTheme)

// Or light/dark pair following the system setting
ConferBotChatView(
    lightTheme = brandTheme,
    darkTheme = DarkTheme,
    useDarkTheme = null  // null = follow system
)

import com.conferbot.sdk.models.ConferBotCustomization

Conferbot.initialize(
    context = this,
    apiKey = "conf_test_key",
    botId = "YOUR_BOT_ID",
    customization = ConferBotCustomization(
        primaryColor = ConferBotCustomization.parseColor("#FF6B6B"),
        headerTitle = "Customer Support",
        enableAvatar = true,
        botBubbleColor = ConferBotCustomization.parseColor("#0100EC"),
        userBubbleColor = ConferBotCustomization.parseColor("#EDEDED")
    )
)

Conferbot.initiateHandover(message = "I need help with billing")

import com.conferbot.sdk.core.Conferbot
import com.conferbot.sdk.core.ConferBotEventListener
import com.conferbot.sdk.models.Agent
import com.conferbot.sdk.models.RecordItem

Conferbot.setEventListener(object : ConferBotEventListener {
    override fun onAgentJoined(agent: Agent) { /* show "Talking to ${agent.name}" */ }
    override fun onAgentLeft(agent: Agent) { }
    override fun onTypingIndicator(isTyping: Boolean) { }
    override fun onMessageReceived(message: RecordItem) { }
    override fun onSessionStarted(sessionId: String) { }
    override fun onSessionEnded(sessionId: String) { }
    override fun onUnreadCountChanged(count: Int) { }
})

import com.conferbot.sdk.models.SocketEvents
import io.socket.emitter.Emitter

val listener = Emitter.Listener { args -> /* JSONObject payload in args[0] */ }
Conferbot.on(SocketEvents.AGENT_ACCEPTED, listener)
Conferbot.on(SocketEvents.AGENT_MESSAGE, listener)
Conferbot.off(SocketEvents.AGENT_ACCEPTED, listener)

val isOnline by Conferbot.isOnline.collectAsState()
val pending by Conferbot.pendingMessageCount.collectAsState()
val syncing by Conferbot.isSyncingQueue.collectAsState()

Conferbot.processOfflineQueue()      // force a sync attempt
Conferbot.clearOfflineQueue()        // drop all queued messages
Conferbot.clearCurrentSessionQueue() // drop queued messages for this session

lifecycleScope.launch {
    if (Conferbot.hasPersistedSession()) {          // suspend fun
        val result = Conferbot.restorePersistedSession()  // suspend fun
        if (result.success) {
            // History is back in Conferbot.record, socket room rejoined,
            // analytics resumed. onSessionStarted fires with the restored ID.
        }
    }
    Conferbot.openChat(this@MainActivity)
}

Conferbot.initialize(
    context = this,
    apiKey = "conf_test_key",
    botId = "YOUR_BOT_ID",
    paginationConfig = PaginationConfig(
        pageSize = 50,
        maxMemoryMessages = 100,
        backgroundMemoryLimit = 50,
        paginationThreshold = 10
    )
)

Conferbot.setEventListener(object : ConferBotEventListener {
    override fun onSessionStarted(sessionId: String) {
        FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
            if (task.isSuccessful) Conferbot.registerPushToken(task.result)
        }
    }
})

class MyMessagingService : FirebaseMessagingService() {
    override fun onMessageReceived(message: RemoteMessage) {
        if (Conferbot.handlePushNotification(message.data)) return
        // Handle your own notifications
    }

    override fun onNewToken(token: String) {
        Conferbot.registerPushToken(token)
    }
}

import com.conferbot.sdk.notifications.NotificationSettings

Conferbot.updateNotificationSettings(
    NotificationSettings(
        enabled = true,
        soundEnabled = true,
        vibrationEnabled = true,
        showPreview = true,
        showInForeground = false,   // rely on in-app banners while foregrounded
        showNewMessages = true,
        showAgentJoined = true,
        showAgentLeft = true,
        showChatEnded = true,
        showQueueUpdates = true
    )
)

// In-app banners need to know the visible Activity:
override fun onResume() { super.onResume(); Conferbot.setCurrentActivity(this) }
override fun onPause() { Conferbot.setCurrentActivity(null); super.onPause() }

// Deep-link taps into your own chat screen instead of the SDK's:
Conferbot.setNotificationChatActivity(MyChatActivity::class.java)

-keep class com.conferbot.sdk.** { *; }
-keep class io.socket.** { *; }