SDK Android Construtor de Chatbot

Android dominates the global mobile market with over 3 billion active devices worldwide. For businesses building native Android apps with Kotlin or Java, in-app customer engagement is not a luxury — it is a retention necessity. Users who encounter friction when seeking help or guidance will uninstall and switch to a competitor, often within the first three days.

The Conferbot Android SDK brings a fully native chatbot experience to your Android app. Built for modern Android development, the SDK supports both Jetpack Compose and traditional XML layouts, follows Material You (Material Design 3) guidelines, leverages Kotlin coroutines for asynchronous operations, and integrates seamlessly with Firebase Cloud Messaging for push notifications.

Unlike WebView-based chat solutions that feel foreign and perform poorly, the Conferbot Android SDK renders native Android views that match your app's look, feel, and performance standards. Users interact with the chatbot as naturally as any other screen in your app. The bot itself is powered by the same no-code builder and AI engine that drives all Conferbot channels — build once, deploy everywhere.

This guide covers installation, Compose and XML integration, key features, theming, and best practices for delivering a production-grade chatbot experience in your Android app in 2026.

New to chatbot building? Start with our complete guide to building a chatbot without coding. The same chatbot you build for your Android app works on your website, WhatsApp, Messenger, and iOS app. Browse our template library for pre-built in-app chatbot flows.

Source code & documentation: conferbot-android on GitHub | Available on Maven Central

The Conferbot Android SDK is distributed via Maven Central and integrates into your Gradle build like any standard Android library.

Step 1: Add the Repository

In your project-level build.gradle or settings.gradle, ensure Maven Central is included:

repositories { mavenCentral() }

Step 2: Add the Dependency

In your app-level build.gradle:

implementation 'com.conferbot:sdk:1.0.0'

For Jetpack Compose support, also add:

implementation 'com.conferbot:sdk-compose:1.0.0'

Step 3: Sync and Initialize

Sync Gradle files, then initialize the SDK in your Application class:

Conferbot.initialize(context, "YOUR_BOT_ID")

Step 4: Add the Chat UI

Jetpack Compose:

ConferbotChatScreen(modifier = Modifier.fillMaxSize())

Or use the floating action button composable:

ConferbotFloatingButton()

XML Layouts:

Launch the chat as an Activity:

ConferbotChatActivity.launch(context)

Or embed as a Fragment:

ConferbotChatFragment.newInstance()

Step 5: Configure Push Notifications (Optional)

The SDK integrates with Firebase Cloud Messaging (FCM):

1. Set up FCM in your Firebase project
2. Pass the FCM token to the SDK: Conferbot.setDeviceToken(token)
3. The SDK handles incoming notification payloads and displays notifications automatically

Basic integration takes 15 minutes. The SDK supports API 21+ (Android 5.0 Lollipop and above), covering 99%+ of active Android devices.

The Conferbot Android SDK is built by Android developers, for Android developers. It follows modern Android architecture patterns and leverages the latest platform capabilities.

Jetpack Compose Support

First-class Jetpack Compose composables for the entire chat UI. Use ConferbotChatScreen, ConferbotFloatingButton, and ConferbotMessageList directly in your Compose layouts. The composables follow Compose best practices: stateless where possible, recomposition-efficient, and compatible with Navigation Compose.

Traditional XML Support

For apps not yet migrated to Compose, the SDK provides Activity and Fragment implementations. ConferbotChatActivity launches a full-screen chat, while ConferbotChatFragment embeds into your existing Fragment-based navigation. Both support the same feature set as the Compose version.

Material You (Material Design 3)

The SDK renders Material Design 3 components that respond to your app's dynamic color scheme on Android 12+. On older devices, the SDK falls back to your configured color scheme. Chat bubbles, buttons, input fields, and headers all follow Material 3 specs for shape, typography, and color.

Kotlin Coroutines

All asynchronous operations use Kotlin coroutines with structured concurrency. Message sending, receiving, and network operations run on appropriate dispatchers without blocking the UI thread. The SDK exposes Flow-based APIs for observing chat state, message streams, and connection status.

FCM Push Notifications

When the bot sends a message while the app is backgrounded, users receive a push notification via Firebase Cloud Messaging. Tap the notification to open the chat directly. The SDK handles notification payload parsing and deep linking automatically.

Offline Message Queuing

Messages typed while offline are stored in a local queue and sent automatically when connectivity returns. The SDK uses Android's ConnectivityManager to detect network state changes, ensuring no messages are lost during transient network disruptions.

ProGuard and R8 Compatible

The SDK ships with its own ProGuard rules. No additional configuration needed for release builds with code shrinking enabled. Tested with both ProGuard and R8 optimizers.

Kotlin/Compose Integration Details

The SDK is built with Kotlin-first principles, leveraging modern language features like data classes, sealed interfaces, extension functions, and type-safe builders. For Compose users, the chat UI composables follow the slot-based API pattern familiar from Material 3 components. You can pass custom content as trailing lambdas: ConferbotChatScreen(headerContent = { CustomHeader() }, inputContent = { CustomInputBar() }). State management uses remember and derivedStateOf internally, and the SDK exposes chat state as StateFlow objects compatible with collectAsStateWithLifecycle(). For Compose Navigation integration, the SDK provides a conferbotNavGraph() extension that adds chat routes to your NavHost.

Material Design 3 Deep Dive

The SDK fully implements Material Design 3 (Material You) specifications. On Android 12+ devices, when dynamic color is enabled, the chat UI extracts colors from the user's wallpaper and applies them across all components -- message bubbles, buttons, headers, input fields, and status indicators. The shape system follows M3's shape scale (extra-small through extra-large corner radius), and typography uses M3's type scale (display, headline, title, body, label). This means the chatbot seamlessly adapts to each user's personal device theme, feeling like a native part of your app rather than a third-party overlay.

Performance Benchmarks

The Conferbot Android SDK is optimized for performance across the Android device ecosystem:

Metric	Conferbot Native SDK	WebView Chat	Hybrid (React Native bridge)
Initial Load Time	380ms	2,400-3,200ms	1,100-1,800ms
Memory Usage (idle)	12-18MB	65-95MB	35-55MB
Memory Usage (active chat)	22-30MB	85-130MB	50-75MB
Battery Drain (1hr active use)	0.8% per hour	3.5-4.5% per hour	2.0-2.8% per hour
Frame Rate (scrolling)	60fps constant	30-45fps (drops on scroll)	50-58fps
APK Size Impact	+1.2MB	+0.1MB (but WebView overhead)	+8-12MB (JS engine)
Cold Start Penalty	None	800-1200ms WebView init	400-600ms JS engine init
Offline Support	Full (Room database)	None	Partial
Push Notifications	Native FCM	Not possible	Requires bridge
Material You Theming	Full dynamic color	CSS only	Limited

These benchmarks are measured on a mid-range device (Pixel 6a / Samsung Galaxy A54, 6GB RAM, Android 14) with a conversation containing 50 messages. On low-end devices common in emerging markets (India, Southeast Asia, Africa) with 2-3GB RAM, the native SDK's advantage becomes critical — where WebView-based solutions may lag or crash entirely, the native SDK maintains smooth 60fps interactions and stays well within memory limits.

Room Database for Offline Storage

The Conferbot Android SDK uses the Room persistence library for reliable local storage of conversation history, pending messages, and user session data. Room provides compile-time SQL verification, reducing the risk of runtime database errors. The local database stores the last 500 messages per conversation by default (configurable via ConferbotConfig.maxLocalMessages), enabling fast chat screen loading without network round-trips. Offline message queuing uses Room's transaction support to ensure message ordering consistency — if three messages are queued offline, they are sent in the exact order typed once connectivity returns. The SDK monitors network state changes via ConnectivityManager's NetworkCallback API, triggering queue flush within 100ms of reconnection.

FCM Push Notifications Deep-Dive

Setting up FCM push notifications with the Conferbot SDK requires three steps. First, add Firebase to your project via the Firebase Console and include the google-services.json in your app module. Second, create a FirebaseMessagingService subclass and pass the token to the SDK with Conferbot.setDeviceToken(token) in the onNewToken callback. Third, in onMessageReceived, pass the RemoteMessage to Conferbot.handlePushNotification(remoteMessage) — the SDK determines if the notification is Conferbot-related and handles it appropriately, ignoring non-Conferbot payloads. The SDK creates a notification channel named "Chat Messages" on Android 8.0+ and supports custom notification sounds, LED colors, and vibration patterns configured through ConferbotNotificationConfig. Tapping the notification deep-links directly to the chat screen, providing a seamless re-engagement experience.

App Store Optimization Tips

Adding in-app chat support improves your Google Play Store metrics in measurable ways. Apps with responsive in-app support see 30% fewer 1-star reviews related to unresolved customer issues, because users have a direct channel to resolve problems before resorting to negative reviews. Include "in-app chat support" and "24/7 customer service" in your Play Store description to improve discoverability for support-related searches. The Conferbot SDK's lightweight footprint (1.2MB APK size increase) keeps your app within Google Play's recommended size thresholds. Monitor your Android Vitals dashboard — the SDK is engineered for zero impact on ANR (Application Not Responding) rates and crash-free session metrics, both of which directly affect your Play Store ranking and recommendation visibility.

The SDK integrates with Android's theming system for seamless visual consistency with your app.

Theme Configuration

Configure the chat appearance through ConferbotTheme:

• primaryColor — Accent color for send button, links, and interactive elements
• surfaceColor — Background color for the chat screen
• userBubbleColor / botBubbleColor — Separate colors for user and bot message bubbles
• typography — Custom TypeStyle or font family for all text elements
• shapes — Corner radius for bubbles, cards, and buttons following Material 3 shape scale
• botAvatar — Custom drawable or URL for the bot avatar

Dynamic Color (Android 12+)

On Android 12 and above, the SDK can extract colors from the user's wallpaper using Material You dynamic color. Enable this with a single flag: useDynamicColor = true. Your chatbot adapts to each user's personal color theme.

Dark Theme Support

The SDK automatically respects the system dark theme or your app's AppCompatDelegate.setDefaultNightMode setting. Provide separate light and dark color configurations, or let Material You handle the adaptation automatically.

Event Listeners

Register listeners for chatbot events:

• OnMessageReceivedListener — Bot message arrives
• OnConversationEndedListener — A conversation flow completes
• OnHandoffListener — Conversation transfers to a live agent
• OnDataCapturedListener — User provides data through the bot flow
• OnErrorListener — SDK encounters an error

For Compose users, these events are also available as LaunchedEffect-compatible flows.

Custom Views

Replace default UI elements with your own implementations. The SDK provides interfaces for custom message bubble views, input bar views, header views, and quick reply layouts — both in Compose (composable slots) and XML (ViewFactory pattern).

Android's massive global install base means your app serves diverse users with diverse needs. Here are the chatbot use cases that deliver the highest impact.

Customer Support at Scale

Android apps in markets like India, Brazil, and Southeast Asia serve tens of millions of users. In-app chatbot support handles the volume that human agents cannot — resolving common inquiries instantly and routing complex issues to live agents. Apps with in-app support see 30% fewer negative Play Store reviews related to support responsiveness.

Guided Onboarding

Walk new users through your app's features conversationally. Instead of overwhelming users with all features at once, the chatbot asks what they want to achieve and guides them to the relevant screen with step-by-step instructions. This is especially effective for complex apps like fintech, health, and productivity tools.

Order and Delivery Tracking

E-commerce and food delivery apps can let users check order status, modify orders, report issues, and request refunds through conversational chat. The chatbot pulls order data in real time and presents it clearly, reducing the need for users to navigate through multiple screens.

Subscription and Payment Support

Handle billing inquiries, explain subscription tiers, process upgrade requests, and troubleshoot payment failures. For apps with in-app purchases or subscriptions, chatbot-driven support reduces involuntary churn from unresolved billing issues by 15-25%.

Feedback and Bug Reporting

Replace clunky bug report forms with conversational feedback collection. The chatbot asks what happened, when it happened, and what the user expected — collecting structured reports that developers can act on. Users find this 3x less frustrating than traditional forms.

Adding a chatbot to your Android app with the Conferbot SDK is straightforward for any Android developer familiar with Gradle dependencies and modern Android architecture.

Quick Start

1. Build your chatbot in the Conferbot visual builder — the same bot works on your app, website, and messaging channels
2. Add the Gradle dependency — implementation 'com.conferbot:sdk:1.0.0'
3. Initialize in Application class — Conferbot.initialize(context, botId)
4. Add the UI — ConferbotChatScreen (Compose) or ConferbotChatActivity/Fragment (XML)
5. Apply your theme — Match your app's Material You color scheme
6. Test on multiple devices — Verify on different API levels, screen sizes, and network conditions

Compose vs XML — Which to Use?

Consideration	Jetpack Compose	XML Layouts
New projects	Recommended	Supported
Existing XML apps	Can mix with ComposeView	Native integration
Customization	Composable slots	ViewFactory pattern
Material You	Full dynamic color	Theme-based
Navigation	Navigation Compose	Fragment navigation

Cross-Channel Deployment

Your Android chatbot is part of Conferbot's omnichannel ecosystem. The same bot logic powers your website widget, WhatsApp, Messenger, and iOS app. Build once, reach users everywhere. A customer who starts a conversation in your Android app can continue it on WhatsApp — conversation context follows seamlessly.

Why Conferbot Android SDK

• Native performance — 60fps Compose and XML rendering, not a WebView wrapper
• Material Design 3 — Full Material You dynamic color on Android 12+
• Kotlin-first — Coroutines, Flow, sealed classes, and modern Kotlin patterns
• Jetpack Compose — First-class composables with slot-based customization
• FCM push notifications — Native Firebase integration for background messaging
• Offline support — Message queuing with automatic sync on reconnection
• AI-powered — AI knowledge base and OpenAI for intelligent responses
• Omnichannel — Same bot on iOS, website, WhatsApp, and more
• Analytics — Track in-app engagement with built-in analytics

The Android SDK is included in Pro plans and above. View pricing for details, or start building your chatbot today and add Android integration when your app is ready. See how Conferbot compares to other chatbot platforms for mobile SDK capabilities.

The Conferbot Android SDK supports advanced integration patterns that give your team full control over the chat experience while maintaining the convenience of a managed platform.

Headless Mode

For teams that need complete UI control, the SDK offers a headless mode that provides the messaging engine without any default UI. In headless mode, you receive messages, events, and connection state through Kotlin Flows and coroutine-based APIs, but you render the UI entirely yourself. This is ideal for apps with highly custom design systems, games that embed chat inside a WebGL or Canvas view, or apps where the chatbot interaction must integrate into an existing conversation screen. Initialize headless mode with Conferbot.initializeHeadless(context, botId) and observe messages via Conferbot.messagesFlow.

Custom UI with Material Design 3

When headless mode is too low-level but the default UI needs significant changes, use the SDK's slot-based composable API to replace individual UI elements. Material Design 3 theming means your custom components inherit dynamic color, shape, and typography tokens automatically. Replace the message bubble with a custom composable that adds reaction buttons, star ratings, or product cards. Replace the input bar with a composable that includes voice input, camera access, or file attachment buttons. All custom components receive the same ChatMessage data class, ensuring type safety and consistency.

Dark Mode and Themed Variants

The SDK respects AppCompatDelegate.setDefaultNightMode() and the system dark theme setting. On Android 12+ with dynamic color enabled, the chat UI adapts to each user's wallpaper palette in both light and dark modes. You can provide explicit ConferbotTheme.Light and ConferbotTheme.Dark configurations for apps that need precise color control. The SDK also supports Material Design 3 color harmonization — if your brand color does not blend well with a user's wallpaper palette, the SDK harmonizes it to produce a visually cohesive result without losing brand identity.

RTL (Right-to-Left) Layout Support

For apps serving Arabic, Hebrew, Urdu, or Persian-speaking users, the SDK provides full RTL layout support. Message bubbles, input fields, navigation elements, and quick reply buttons mirror correctly when the device locale is RTL. The SDK uses Android's LayoutDirection API and Compose's LocalLayoutDirection to detect and apply the correct layout direction automatically. For apps that support both LTR and RTL languages, the SDK handles dynamic direction changes without requiring an activity restart.

Deep Linking and Navigation

The SDK supports Android's deep linking system. Configure deep links to open the chat screen directly from push notifications, email links, QR codes, or other apps. For apps using Navigation Compose, the SDK provides a conferbotNavGraph() extension that adds chat-related destinations to your NavHost. For apps using Fragment-based navigation, ConferbotChatFragment integrates with the Navigation Component's NavGraph XML definitions. Deep link URIs follow the pattern conferbot://chat/{conversationId} and can include query parameters for pre-filled messages or context data.

Analytics and Event Tracking Integration

The SDK integrates with popular analytics platforms. Forward chatbot events to Firebase Analytics, Amplitude, Mixpanel, or your custom analytics pipeline using the ConferbotEventListener interface. Track metrics like chat open rate, average messages per session, conversation completion rate, and handoff frequency. Combine these with your existing app analytics to understand how chatbot interactions correlate with retention, revenue, and feature adoption. For apps using Conferbot's built-in analytics, all metrics are tracked automatically with zero configuration.

Multi-Bot Support

Enterprise apps sometimes need multiple chatbot instances — a support bot on the account screen, a sales bot on the product catalog, and an onboarding bot for first-time users. The SDK supports multiple bot instances through Conferbot.createInstance(botId), each with its own configuration, theme, and conversation state. Instances share a single WebSocket connection for efficiency while maintaining separate message histories and session data.

Security and Data Privacy

The SDK stores conversation data in an encrypted Room database when configured with ConferbotConfig.encryptLocalStorage = true. Network traffic uses TLS 1.3 exclusively. The SDK does not collect device identifiers, advertising IDs, or location data unless explicitly enabled by your app. For apps subject to GDPR, CCPA, or other privacy regulations, the SDK provides Conferbot.clearUserData() to purge all locally stored conversation history and session data on demand. Review our data security and privacy guide for detailed compliance information.

Push notifications are the primary re-engagement mechanism for mobile apps. The Conferbot Android SDK integrates with Firebase Cloud Messaging to deliver timely, relevant notifications that bring users back into conversations.

FCM Setup and Configuration

Setting up FCM with the Conferbot SDK involves four steps: (1) Add Firebase to your Android project via the Firebase Console and download the google-services.json file, (2) Add the Firebase Messaging dependency to your app-level build.gradle, (3) Create a FirebaseMessagingService subclass that passes tokens and messages to the SDK, and (4) Configure notification preferences through ConferbotNotificationConfig. The SDK handles payload parsing, notification display, and deep linking to the chat screen automatically.

Notification Channels (Android 8.0+)

Android 8.0 introduced notification channels that give users granular control over notification behavior. The SDK creates a default "Chat Messages" channel with importance level HIGH, which shows heads-up notifications with sound. You can customize the channel settings including notification sound (use a custom sound file in res/raw for brand consistency), vibration pattern (the default is a short double-buzz), LED color (for devices with notification LEDs), and whether the notification shows on the lock screen. For apps with multiple bot instances, the SDK creates separate notification channels per bot, allowing users to independently control notifications for support messages versus promotional messages.

In-App vs Push Notifications

The SDK distinguishes between in-app notifications (shown while the user is actively using your app) and push notifications (shown when the app is backgrounded or closed). In-app notifications appear as a subtle banner at the top of the screen and do not disrupt the user's current activity. Push notifications use the standard Android notification system. Configure which notification type to use for different message categories:

Message Type	App in Foreground	App in Background	App Closed
Bot response	In-app banner	Push notification	Push notification
Live agent message	In-app banner + sound	High-priority push	High-priority push
Proactive campaign	In-app banner (optional)	Standard push	Standard push
Conversation resolved	In-app banner	Silent push (badge update)	Silent push

Re-Engagement Campaigns

Beyond reactive notifications, the SDK supports proactive re-engagement campaigns. When a user has not opened the app in a configurable period (default: 7 days), the bot can send a personalized push notification to re-engage them. Effective re-engagement messages include abandoned conversation reminders ("You had a question about our pricing — want to continue?"), new feature announcements ("We just launched a feature you asked about"), and personalized recommendations based on previous chatbot interactions. Re-engagement notifications achieve an average 12-18% open rate on Android, significantly higher than email campaigns at 3-5%. The SDK respects Android's notification best practices — it never sends more than one re-engagement notification per 48-hour window and honors the user's Do Not Disturb settings.

Notification Grouping and Bundling

When multiple messages arrive while the app is backgrounded, the SDK groups them into a single expandable notification using Android's NotificationCompat.InboxStyle. The summary notification shows the count ("3 new messages from Conferbot") while expanding reveals individual message previews. This prevents notification spam and respects the user's notification tray. On Android 12+, the SDK uses the updated notification trampoline restrictions, launching the chat screen directly from the notification intent without intermediate activities.

For a complete guide on mobile engagement strategies, see our customer engagement guide. Compare the Android SDK's notification capabilities with other platforms on our comparison page.

Choosing the right in-app chat SDK for your Android app is a critical decision that affects performance, cost, and development velocity. Here is a detailed comparison of the Conferbot Android SDK against the most popular alternatives in 2026.

Criteria	Conferbot Android SDK	Intercom Android SDK	Zendesk Android SDK	WebView Chat Widget
Architecture	Native Kotlin + Compose	Native (Kotlin/Java)	Native (Java)	WebView wrapper
Initial Load Time	380ms	900-1,200ms	800-1,100ms	2,400-3,200ms
Memory Usage (idle)	12-18MB	30-45MB	25-40MB	65-95MB
Battery Drain (1hr)	0.8%	1.5-2.0%	1.2-1.8%	3.5-4.5%
APK Size Impact	+1.2MB	+8-12MB	+6-9MB	+0.1MB (but WebView overhead)
Frame Rate (scrolling)	60fps constant	55-60fps	50-58fps	30-45fps
Jetpack Compose Support	Native composables	UIKit wrapper	Not available	Not applicable
Material You Dynamic Color	Full support	Limited	Not available	CSS only
No-Code Bot Builder	Full visual builder + AI	Limited flow builder	Basic answer bot	Depends on provider
AI Capabilities	OpenAI + knowledge base	Fin AI ($0.99/resolution)	Basic AI answers	Varies
Offline Message Queue	Room database backed	Yes	Yes	None
Omnichannel	All channels from one builder	Website + mobile	Website + email + mobile	Website only
Pricing (Starter)	Free tier available	$74/seat/month	$55/agent/month	Varies
Calendar Booking	Built-in	Third-party integration	Not available	Varies

The Conferbot Android SDK delivers the best combination of native performance, lightweight footprint, and full-featured automation. While Intercom and Zendesk are established support platforms, their SDKs carry significantly larger APK size impacts (8-12MB vs 1.2MB), higher per-seat pricing, and less flexible bot building. For Android teams building with Jetpack Compose and Material Design 3, Conferbot is the only SDK with native composable support and full dynamic color integration. The same chatbot you build for Android deploys to iOS, your website, WhatsApp, Messenger, and other channels — all from one visual builder. See pricing for plan details or compare platforms for the complete feature breakdown.