Mobile SDKs

import { createHmac } from 'node:crypto';

// The website's identity secret (Websites → your website → Security). Server only.
export function zebchatHash(userId) {
  return createHmac('sha256', process.env.ZEBCHAT_IDENTITY_SECRET)
    .update(String(userId), 'utf8')
    .digest('hex');
}

// Return it with your user's profile, e.g. { id: '42', name: 'Ana', zebchatHash: zebchatHash('42') }

// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}

// app/build.gradle.kts
dependencies {
    implementation("com.zebchat:chat:1.0.0")
}

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        ZebChat.configure(this, siteKey = "zc_…", options = ZebChatOptions(locale = "auto"))
    }
}

// Anywhere, e.g. a "Help" button:
ZebChat.show(activity)

ZebChat.setUser(ZebChatUser(id = "42", email = "[email protected]", name = "Ana", hash = hashFromYourServer))
ZebChat.logout()   // on sign-out: removes this device's push registration, then forgets the visitor

ZebChat.trackScreen("Checkout")   // agents see app://<your app id>/Checkout (buffered offline, max 20)

val listener = ZebChat.addUnreadListener { count -> badge.text = count.toString() }
ZebChat.removeUnreadListener(listener)

class MyMessagingService : FirebaseMessagingService() {
    override fun onNewToken(token: String) {
        ZebChat.setPushToken(token)
    }

    override fun onMessageReceived(message: RemoteMessage) {
        if (ZebChat.isZebChatNotification(message.data)) {
            // App in the foreground: FCM does not display it, so the SDK does (channel zebchat_chat).
            ZebChat.showNotification(this, message.data)
            return
        }
        // … your own messages
    }
}

// At start (after configure), as onNewToken only fires on changes:
FirebaseMessaging.getInstance().token.addOnSuccessListener { ZebChat.setPushToken(it) }

// In your launcher Activity: a tap on a notification FCM displayed in the background.
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    ZebChat.handleNotificationTap(this, intent.extras)
}
override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    ZebChat.handleNotificationTap(this, intent.extras)
}

// Xcode → File → Add Package Dependencies…
https://github.com/zebchat/zebchat-ios

// or in Package.swift
.package(url: "https://github.com/zebchat/zebchat-ios", from: "1.0.0")

pod 'ZebChat', '~> 1.0'

import ZebChat

// AppDelegate.application(_:didFinishLaunchingWithOptions:)
ZebChat.configure(siteKey: "zc_…")

// Open the chat (full screen, modal)
ZebChat.show(from: viewController)

// `hash` is computed on YOUR server; never put the identity secret in the app.
ZebChat.setUser(ZebChatUser(id: "42", email: "[email protected]", name: "Ana", hash: hashFromServer))
ZebChat.logout()   // sign-out: removes the push registration, then forgets the user and the visitor

ZebChat.trackScreen("Checkout")

let token = ZebChat.addUnreadListener { count in helpButton.badge = count }
ZebChat.removeUnreadListener(token)

import FirebaseCore
import FirebaseMessaging
import UserNotifications
import ZebChat

// In your AppDelegate (UNUserNotificationCenterDelegate, MessagingDelegate):
func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    FirebaseApp.configure()
    ZebChat.configure(siteKey: "zc_…")
    Messaging.messaging().delegate = self
    UNUserNotificationCenter.current().delegate = self
    // Ask when it suits your app (the SDK never asks for permission itself).
    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { _, _ in }
    application.registerForRemoteNotifications()
    return true
}

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    Messaging.messaging().apnsToken = deviceToken
}

func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    if let fcmToken { ZebChat.setPushToken(fcmToken) }
}

// A push while the app is open: no banner while the chat is visible.
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification,
                            withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    let userInfo = notification.request.content.userInfo
    if ZebChat.notificationReceived(userInfo) {
        completionHandler(ZebChat.isChatVisible ? [] : [.banner, .sound])
    } else {
        completionHandler([.banner, .sound, .badge])
    }
}

// A tapped push opens the chat (also after a cold start).
func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse,
                            withCompletionHandler completionHandler: @escaping () -> Void) {
    if let root = window?.rootViewController {
        ZebChat.handleNotificationTap(response.notification.request.content.userInfo, from: root)
    }
    completionHandler()
}

flutter pub add zebchat_flutter

# iOS: in ios/Podfile set  platform :ios, '14.0'  then
cd ios && pod install

import 'package:flutter/material.dart';
import 'package:zebchat_flutter/zebchat_flutter.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await ZebChat.configure(siteKey: 'zc_your_site_key'); // locale: 'auto' by default
  runApp(const MyApp());
}

// Anywhere, for example a "Help" button:
ElevatedButton(onPressed: ZebChat.show, child: const Text('Chat with us'));

await ZebChat.setUser(ZebChatUser(
  id: user.id,
  email: user.email,
  name: user.name,
  hash: user.zebchatHash, // from your server
));
await ZebChat.logout(); // on sign-out

ZebChat.trackScreen('Checkout'); // or a NavigatorObserver that tracks named routes

StreamBuilder<int>(stream: ZebChat.unreadCount, initialData: 0, builder: …);

import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:zebchat_flutter/zebchat_flutter.dart';

Future<void> setUpZebChatPush() async {
  final messaging = FirebaseMessaging.instance;
  await messaging.requestPermission(); // your app decides when to ask

  final token = await messaging.getToken();
  if (token != null) await ZebChat.setPushToken(token);
  messaging.onTokenRefresh.listen(ZebChat.setPushToken);

  // Android: FCM does not display notifications while the app is in the foreground.
  FirebaseMessaging.onMessage.listen((message) {
    if (ZebChat.isZebChatNotification(message.data)) {
      ZebChat.showNotification(message.data);
    }
  });

  // Tapped while in the background, or the tap that launched the app.
  FirebaseMessaging.onMessageOpenedApp.listen((message) {
    ZebChat.handleNotificationTap(message.data);
  });
  final initial = await messaging.getInitialMessage();
  if (initial != null) await ZebChat.handleNotificationTap(initial.data);
}

npm install @zebchat/react-native
# iOS
cd ios && pod install

import { useEffect } from 'react';
import { Button } from 'react-native';
import { ZebChat, useZebChatUnread } from '@zebchat/react-native';

export function App() {
  useEffect(() => {
    ZebChat.configure({ siteKey: 'zc_your_site_key' });
  }, []);

  const unread = useZebChatUnread();
  return <Button title={`Chat with us (${unread})`} onPress={() => ZebChat.show()} />;
}

// `hash` is the HMAC your server computes for identity verification.
ZebChat.setUser({ id: user.id, email: user.email, name: user.name, hash: user.zebchatHash });
ZebChat.logout(); // removes this device's push token, then forgets the user and the visitor

ZebChat.trackScreen('Checkout');

import { PermissionsAndroid, Platform } from 'react-native';
import messaging from '@react-native-firebase/messaging';
import { ZebChat } from '@zebchat/react-native';

export async function setUpZebChatPush() {
  if (Platform.OS === 'android' && Platform.Version >= 33) {
    await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
  } else {
    await messaging().requestPermission();
  }

  ZebChat.setPushToken(await messaging().getToken());
  messaging().onTokenRefresh((token) => ZebChat.setPushToken(token));

  // App in the foreground: Android shows it on the zebchat_chat channel.
  messaging().onMessage(async (message) => {
    if (ZebChat.isZebChatNotification(message.data)) ZebChat.showNotification(message.data);
  });

  // Tapped while in the background, or the tap that launched the app.
  messaging().onNotificationOpenedApp((message) => ZebChat.handleNotificationTap(message.data));
  const initial = await messaging().getInitialNotification();
  if (initial) ZebChat.handleNotificationTap(initial.data);
}

<key>NSCameraUsageDescription</key>
<string>Take a photo to send in the chat.</string>
<key>NSPhotoLibraryUsageDescription</key>
<string>Choose photos to send in the chat.</string>