@kindly-ai/react-native 0.1.0

package/android/src/main/java/com/kindlyai/reactnative/KindlyReactNativeModule.kt

@@ -0,0 +1,445 @@
+package com.kindlyai.reactnative
+
+import android.app.Activity
+import android.app.Application
+import android.net.Uri
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.firebase.messaging.RemoteMessage
+import androidx.compose.ui.graphics.Color
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+import no.kindly.chatsdk.chat.AuthTokenCallback
+import no.kindly.chatsdk.chat.ChatKindlySDK
+import no.kindly.chatsdk.chat.common.CallbackHandover
+import no.kindly.chatsdk.chat.common.KindlySDKInteraction
+import no.kindly.chatsdk.chat.domain.MessageChat
+import no.kindly.chatsdk.chat.domain.entites.ButtonChat
+import no.kindly.chatsdk.chat.domain.entites.ExternalNotification
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * KindlyReactNativeModule — Kotlin TurboModule that bridges JS calls into
+ * the Kindly Android SDK (`ChatKindlySDK`).
+ *
+ * Symmetric with `flutter-sdk/.../KindlyPlugin.kt`. Major differences from
+ * the Flutter version:
+ *   1. Extends the codegen-generated `NativeKindlyReactNativeSpec` abstract
+ *      class (not `MethodCallHandler`) — RN's TurboModule contract.
+ *   2. JS→native calls arrive as method invocations on this class; native→JS
+ *      callbacks fire via `DeviceEventManagerModule.RCTDeviceEventEmitter`.
+ *   3. Sync-bool delegate callbacks (`shouldHandleLink`,
+ *      `shouldHandleNotification`) use a request-id round-trip — native fires
+ *      an event with a UUID, blocks on a `Map<id, CompletableDeferred>` for
+ *      up to 5s, JS replies via `respondToShouldHandle(requestId, value)`.
+ *      Default `true` on timeout — never hang chat UI.
+ *
+ * The codegen-derived `NativeKindlyReactNativeSpec` class is generated at
+ * build time from `src/NativeKindlyReactNative.ts`. Its package is set in
+ * `package.json` -> `codegenConfig.android.javaPackageName` to match this
+ * file's `package` line.
+ */
+class KindlyReactNativeModule(reactContext: ReactApplicationContext) :
+  NativeKindlyReactNativeSpec(reactContext), LifecycleEventListener {
+
+  private val context = reactContext
+  private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+  // Pending request maps for the sync round-trips.
+  private val authPending = ConcurrentHashMap<String, CompletableDeferred<String?>>()
+  private val shouldHandlePending = ConcurrentHashMap<String, CompletableDeferred<Boolean>>()
+
+  // Delegate bridge — set on ChatKindlySDK.`interface` when at least one
+  // delegate flag is on.
+  private var delegateBridge: KindlyDelegateBridge? = null
+
+  init {
+    reactContext.addLifecycleEventListener(this)
+  }
+
+  override fun getName(): String = NAME
+
+  // Required by the codegen-generated spec for event-emitter accounting.
+  override fun addListener(eventName: String) {
+    // No-op — RCTDeviceEventEmitter manages itself on Android.
+  }
+
+  override fun removeListeners(count: Double) {
+    // No-op
+  }
+
+  override fun onHostResume() {}
+  override fun onHostPause() {}
+  override fun onHostDestroy() {
+    // Best-effort — clear any pending deferreds so the JS side doesn't hang.
+    authPending.values.forEach { it.complete(null) }
+    authPending.clear()
+    shouldHandlePending.values.forEach { it.complete(true) }
+    shouldHandlePending.clear()
+  }
+
+  // MARK: - Lifecycle
+
+  override fun start(botKey: String, languageCode: String?, hasAuthCallback: Boolean) {
+    val app = context.applicationContext as? Application
+    if (app == null) return
+
+    val authCallback: AuthTokenCallback? = if (hasAuthCallback) {
+      { _: String ->
+        val deferred = CompletableDeferred<String>()
+        val requestId = UUID.randomUUID().toString()
+        val pending = CompletableDeferred<String?>()
+        authPending[requestId] = pending
+
+        emitEvent("KindlyGetAuthToken", Arguments.createMap().apply {
+          putString("requestId", requestId)
+        })
+
+        // Fan out to the SDK's deferred — the SDK consumes it on its own thread.
+        scope.launch {
+          val tok = pending.await()
+          if (tok != null) deferred.complete(tok)
+          else deferred.completeExceptionally(IllegalStateException("Auth token not provided"))
+        }
+        deferred
+      }
+    } else {
+      null
+    }
+
+    ChatKindlySDK.start(
+      application = app,
+      botKey = botKey,
+      languageCode = languageCode ?: "en",
+      authTokenCallback = authCallback,
+    )
+  }
+
+  override fun displayChat(languageCode: String?, triggerDialogueId: String?) {
+    val act = currentActivity ?: return
+    ChatKindlySDK.displayChat(act)
+    if (triggerDialogueId != null) {
+      ChatKindlySDK.triggerDialogue(triggerDialogueId)
+    }
+  }
+
+  override fun launchChat(triggerDialogueId: String?) {
+    val act = currentActivity ?: return
+    ChatKindlySDK.launchChat(context = act, triggerDialogueId = triggerDialogueId)
+  }
+
+  override fun closeChat() {
+    ChatKindlySDK.close()
+  }
+
+  override fun endChat(promise: Promise) {
+    try {
+      ChatKindlySDK.endChat()
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject("END_CHAT_FAILED", e.message, e)
+    }
+  }
+
+  override fun kill(promise: Promise) {
+    try {
+      ChatKindlySDK.kill()
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject("KILL_FAILED", e.message, e)
+    }
+  }
+
+  override fun setLanguage(languageCode: String, promise: Promise) {
+    try {
+      ChatKindlySDK.setLanguage(languageCode)
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject("SET_LANGUAGE_FAILED", e.message, e)
+    }
+  }
+
+  // MARK: - Messaging
+
+  override fun sendMessage(message: String, newContext: ReadableMap?, promise: Promise) {
+    val ctx = newContext?.toStringMap()
+    scope.launch {
+      try {
+        val msg = ChatKindlySDK.sendMessage(message, ctx).await()
+        promise.resolve(serializeMessageChat(msg))
+      } catch (e: Throwable) {
+        promise.reject("SEND_MESSAGE_FAILED", e.message, e)
+      }
+    }
+  }
+
+  override fun setNewContext(context: ReadableMap) {
+    ChatKindlySDK.setNewContext(context.toStringMap())
+  }
+
+  override fun clearNewContext() {
+    ChatKindlySDK.clearNewContext()
+  }
+
+  override fun triggerDialogue(dialogueId: String) {
+    ChatKindlySDK.triggerDialogue(dialogueId)
+  }
+
+  override fun clearTriggerDialogue() {
+    ChatKindlySDK.clearTriggerDialog()
+  }
+
+  override fun handleUrl(url: String, promise: Promise) {
+    val act = currentActivity
+    if (act == null) {
+      promise.resolve(false)
+      return
+    }
+    promise.resolve(ChatKindlySDK.handleUrl(act, Uri.parse(url)))
+  }
+
+  // MARK: - Theme
+
+  override fun setCustomTheme(colors: ReadableMap) {
+    fun color(key: String): Color? =
+      if (colors.hasKey(key) && !colors.isNull(key)) Color(colors.getInt(key)) else null
+
+    ChatKindlySDK.setCustomTheme(
+      background = color("background"),
+      botMessageBackground = color("botMessageBackground"),
+      botMessageText = color("botMessageText"),
+      buttonBackground = color("buttonBackground"),
+      buttonOutline = color("buttonOutline"),
+      buttonText = color("buttonText"),
+      chatLogElements = color("chatLogElements"),
+      // Flutter/RN expose navBarBackground / navBarText (iOS naming);
+      // Android maps them to headerBackground / headerText.
+      headerBackground = color("navBarBackground"),
+      headerText = color("navBarText"),
+      inputBackground = color("inputBackground"),
+      inputText = color("inputText"),
+      userMessageBackground = color("userMessageBackground"),
+      userMessageText = color("userMessageText"),
+      maintenanceHeaderBackground = color("maintenanceHeaderBackground"),
+    )
+  }
+
+  override fun clearCustomTheme() {
+    ChatKindlySDK.clearCustomTheme()
+  }
+
+  // MARK: - Push
+
+  override fun setAPNSDeviceToken(token: String) {
+    // iOS-only — accept silently.
+  }
+
+  override fun saveNotificationToken(token: String) {
+    ChatKindlySDK.saveNotificationToken(token)
+  }
+
+  override fun handleNotification(data: ReadableMap) {
+    val rm = mapToRemoteMessage(data) ?: return
+    ChatKindlySDK.handleNotification(rm)
+  }
+
+  override fun isKindlyNotification(data: ReadableMap): Boolean {
+    val rm = mapToRemoteMessage(data) ?: return false
+    return ChatKindlySDK.isKindlyNotification(rm)
+  }
+
+  // MARK: - State / settings
+
+  override fun saveAuthToken(token: String, promise: Promise) {
+    // Android handles auth via AuthTokenCallback; accept symmetrically.
+    promise.resolve(true)
+  }
+
+  override fun isChatDisplayed(promise: Promise) {
+    // Not exposed by Android EntryPoint — always false (matches Flutter SDK).
+    promise.resolve(false)
+  }
+
+  override fun setVerboseLogging(enabled: Boolean) {
+    ChatKindlySDK.verboseLogging = enabled
+  }
+
+  override fun setCrashReporting(enabled: Boolean) {
+    ChatKindlySDK.enableCrashReporting = enabled
+  }
+
+  // MARK: - Round-trip responders (called by JS)
+
+  override fun respondToAuthToken(requestId: String, token: String?) {
+    authPending.remove(requestId)?.complete(token)
+  }
+
+  override fun respondToShouldHandle(requestId: String, value: Boolean) {
+    shouldHandlePending.remove(requestId)?.complete(value)
+  }
+
+  // MARK: - Delegate gating
+
+  override fun setDelegate(
+    onButtonPressed: Boolean,
+    shouldHandleLink: Boolean,
+    shouldHandleNotification: Boolean,
+    onHandover: Boolean,
+  ) {
+    val bridge = delegateBridge ?: KindlyDelegateBridge(this)
+    bridge.hasButtonPressed = onButtonPressed
+    bridge.hasShouldHandleLink = shouldHandleLink
+    bridge.hasShouldHandleNotification = shouldHandleNotification
+    delegateBridge = bridge
+
+    val anySet = onButtonPressed || shouldHandleLink || shouldHandleNotification
+    ChatKindlySDK.`interface` = if (anySet) bridge else null
+  }
+
+  override fun callHandover() {
+    val listener = object : CallbackHandover {
+      override fun callHandover() {
+        emitEvent("KindlyOnHandover", null)
+      }
+    }
+    ChatKindlySDK.callHandover(listener)
+  }
+
+  // MARK: - Event emit helper
+
+  internal fun emitEvent(name: String, body: WritableMap?) {
+    context
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(name, body)
+  }
+
+  /**
+   * Block the calling thread for up to 5s while JS computes a Bool answer.
+   * Default `true` on timeout / no-listener — never hang chat UI.
+   */
+  internal fun blockingShouldHandle(eventName: String, payload: WritableMap): Boolean {
+    val requestId = UUID.randomUUID().toString()
+    val deferred = CompletableDeferred<Boolean>()
+    shouldHandlePending[requestId] = deferred
+    payload.putString("requestId", requestId)
+    emitEvent(eventName, payload)
+    return runBlocking {
+      withTimeoutOrNull(5_000) { deferred.await() } ?: run {
+        shouldHandlePending.remove(requestId)
+        true
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = "KindlyReactNative"
+  }
+}
+
+// MARK: - Helpers
+
+private fun ReadableMap.toStringMap(): Map<String, String> {
+  val out = HashMap<String, String>()
+  val iter = this.keySetIterator()
+  while (iter.hasNextKey()) {
+    val k = iter.nextKey()
+    val v = this.getString(k) ?: continue
+    out[k] = v
+  }
+  return out
+}
+
+private fun serializeMessageChat(msg: MessageChat): WritableMap {
+  return Arguments.createMap().apply {
+    putString("id", msg.id)
+    putString("text", msg.message)
+    putString("created", msg.created)
+    putString("sender", msg.sender)
+    putString("chatId", msg.chatId)
+    putBoolean("isMine", msg.isMine)
+    putString("exchangeId", msg.exchangeId)
+  }
+}
+
+private fun serializeButtonChat(button: ButtonChat): WritableMap {
+  return Arguments.createMap().apply {
+    putString("id", button.id)
+    putString("type", button.buttonType)
+    putString("label", button.label)
+    putString("value", button.value)
+    putInt("index", button.index)
+    putBoolean("hasBeenSelected", button.clicked)
+    putString("languageCode", button.languageCode)
+  }
+}
+
+private fun serializeExternalNotification(notification: ExternalNotification): WritableMap {
+  return Arguments.createMap().apply {
+    putString("id", notification.id)
+    putString("title", notification.title)
+    putString("body", notification.body)
+    val data = Arguments.createMap()
+    notification.data.forEach { (k, v) -> data.putString(k.toString(), v.toString()) }
+    putMap("data", data)
+  }
+}
+
+private fun mapToRemoteMessage(data: ReadableMap): RemoteMessage? {
+  val builder = RemoteMessage.Builder("kindly_rn@gcm.googleapis.com")
+  val iter = data.keySetIterator()
+  while (iter.hasNextKey()) {
+    val k = iter.nextKey()
+    val v = data.getString(k) ?: continue
+    builder.addData(k, v)
+  }
+  return builder.build()
+}
+
+/**
+ * Bridges the Android SDK's `KindlySDKInteraction` interface to the JS-side
+ * callbacks registered via `KindlySDK.setDelegate(...)`.
+ */
+private class KindlyDelegateBridge(
+  private val module: KindlyReactNativeModule,
+) : KindlySDKInteraction {
+  var hasButtonPressed: Boolean = false
+  var hasShouldHandleLink: Boolean = false
+  var hasShouldHandleNotification: Boolean = false
+
+  override fun didPressButton(chatButton: ButtonChat, chatLog: List<MessageChat>) {
+    if (!hasButtonPressed) return
+    val payload = Arguments.createMap().apply {
+      putMap("button", serializeButtonChat(chatButton))
+      val arr = Arguments.createArray()
+      chatLog.forEach { arr.pushMap(serializeMessageChat(it)) }
+      putArray("chatLog", arr)
+    }
+    module.emitEvent("KindlyOnButtonPressed", payload)
+  }
+
+  override fun shouldHandleLink(url: String): Boolean {
+    if (!hasShouldHandleLink) return true
+    val payload = Arguments.createMap().apply { putString("url", url) }
+    return module.blockingShouldHandle("KindlyShouldHandleLink", payload)
+  }
+
+  override fun shouldHandleNotification(notification: ExternalNotification): Boolean {
+    if (!hasShouldHandleNotification) return true
+    val payload = Arguments.createMap().apply {
+      putMap("notification", serializeExternalNotification(notification))
+    }
+    return module.blockingShouldHandle("KindlyShouldHandleNotification", payload)
+  }
+}

package/android/src/main/java/com/kindlyai/reactnative/KindlyReactNativePackage.kt

@@ -0,0 +1,38 @@
+package com.kindlyai.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+/**
+ * Auto-linking entry point for the Kindly React Native package.
+ *
+ * Registered in customer apps automatically via `react-native.config.js`
+ * (autolinking) — they don't need to add anything to MainApplication.kt.
+ *
+ * Returns the single TurboModule we ship: `KindlyReactNativeModule`.
+ */
+class KindlyReactNativePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == KindlyReactNativeModule.NAME) {
+      KindlyReactNativeModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      KindlyReactNativeModule.NAME to ReactModuleInfo(
+        /* name = */ KindlyReactNativeModule.NAME,
+        /* className = */ KindlyReactNativeModule.NAME,
+        /* canOverrideExistingModule = */ false,
+        /* needsEagerInit = */ false,
+        /* isCxxModule = */ false,
+        /* isTurboModule = */ true,
+      )
+    )
+  }
+}

package/ios/Frameworks/Kindly.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>Kindly.framework/Kindly</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>Kindly.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>Kindly.framework/Kindly</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>Kindly.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>