@billdog.io/react-native 1.0.0-beta.2

package/android/src/main/kotlin/io/billdog/reactnative/BillDogSurveyModule.kt

@@ -0,0 +1,427 @@
+package io.billdog.reactnative
+
+import android.app.Activity
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import io.billdog.core.BillDog
+import io.billdog.core.BillDogEventBus
+import io.billdog.survey.SurveyAnswer
+import io.billdog.survey.SurveyChoiceConfig
+import io.billdog.survey.SurveyConfig
+import io.billdog.survey.SurveyLogicRule
+import io.billdog.survey.SurveyMobileDisplayConfig
+import io.billdog.survey.SurveyPageConfig
+import io.billdog.survey.SurveyPresentationHandler
+import io.billdog.survey.SurveyQuestionConfig
+import io.billdog.survey.SurveySubmitResult
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * BillDogSurvey — React Native native module for Android
+ * (`NativeModules.BillDogSurvey`).
+ *
+ * Thin bridge: `@ReactMethod`s delegate to the core survey facades resolved from
+ * `BillDog.getSurveyPresenter()` (billdog-core BillDog.kt:1969) and
+ * `BillDog.getSurveyManager()` (BillDog.kt:2022) — the same entry points the
+ * Flutter plugin uses. The authoritative JS contract is `src/modules/Survey.ts`;
+ * each `BillDogSurvey.<method>(...)` maps to the identically-named method below.
+ * When the SDK is not configured these accessors return null → present rejects
+ * "NO_ACTIVITY"/no-ops, and the data calls resolve their JS defaults.
+ *
+ * `onSurveyCompleted` / `onSurveyDismissed` are emitted by subscribing to the
+ * SDK EventBus SURVEY_COMPLETED (BillDogEventBus.kt:40) / SURVEY_DISMISSED
+ * (:41) signals, which the core SurveyPresenter fires on every present() path.
+ *
+ * ⚠️ VERIFICATION: this file cannot be compiled in this environment — there is
+ * no Android/Gradle toolchain present. It needs a Gradle/Android build to
+ * type-check against io.billdog:billdog-core (which `api`-exposes billdog-survey
+ * models) + kotlinx-coroutines. Every native symbol below is cited to file:line.
+ *
+ * ⚠️ SERIALIZATION SCOPE: kotlinx-serialization-json is `implementation`-scoped
+ * in billdog-survey/billdog-core, so it is NOT on this bridge's compile
+ * classpath. Survey models are therefore hand-serialized via their plain
+ * (String/Int/Boolean/List) fields ONLY; the `JsonElement`-typed maps
+ * (`SurveyConfig.settings`, `SurveyPageConfig.settings`,
+ * `SurveyQuestionConfig.config`/`settings`, logic-rule conditions,
+ * `SurveyAnswer.answer_json`) are omitted. Full-fidelity serialization would
+ * require declaring kotlinx-serialization-json in android/build.gradle.
+ */
+class BillDogSurveyModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val TAG = "BillDogSurvey"
+
+    /** suspend fetch/submit are launched here; cancelled in invalidate(). */
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    private var completedSubscription: String? = null
+    private var dismissedSubscription: String? = null
+
+    override fun getName(): String = "BillDogSurvey"
+
+    init {
+        // Bridge the SDK EventBus survey signals → RN events. subscribe() —
+        // BillDogEventBus.kt:77. These fire for EVERY present() path (the core
+        // SurveyPresenter wrapHandler emits them), so one subscription covers
+        // programmatic present, auto-triggered surveys, and intercepts alike.
+        completedSubscription = BillDogEventBus.subscribe(
+            BillDogEventBus.EventTypes.SURVEY_COMPLETED // BillDogEventBus.kt:40
+        ) { event ->
+            // Bus event carries { survey_id, respondent_id } only — the full
+            // answer set is delivered on the present() promise, not here.
+            emit("onSurveyCompleted", toWritableMap(mapOf(
+                "survey_id" to (event.properties["survey_id"]?.toString() ?: ""),
+                "respondent_id" to (event.properties["respondent_id"]?.toString())
+            )))
+        }
+        dismissedSubscription = BillDogEventBus.subscribe(
+            BillDogEventBus.EventTypes.SURVEY_DISMISSED // BillDogEventBus.kt:41
+        ) { event ->
+            // Bus event carries only { survey_id }; pageIndex is unavailable → 0.
+            emit("onSurveyDismissed", toWritableMap(mapOf(
+                "surveyId" to (event.properties["survey_id"]?.toString() ?: ""),
+                "pageIndex" to 0
+            )))
+        }
+    }
+
+    // ── Lifecycle ──────────────────────────────────────────────────────────
+
+    override fun invalidate() {
+        completedSubscription?.let { BillDogEventBus.unsubscribe(it) } // BillDogEventBus.kt:84
+        dismissedSubscription?.let { BillDogEventBus.unsubscribe(it) }
+        scope.cancel()
+        super.invalidate()
+    }
+
+    @Deprecated("Deprecated in RN; kept for older RN versions that call it instead of invalidate()")
+    override fun onCatalystInstanceDestroy() {
+        completedSubscription?.let { BillDogEventBus.unsubscribe(it) }
+        dismissedSubscription?.let { BillDogEventBus.unsubscribe(it) }
+        scope.cancel()
+        @Suppress("DEPRECATION")
+        super.onCatalystInstanceDestroy()
+    }
+
+    private fun run(promise: Promise, block: suspend () -> Any?) {
+        scope.launch {
+            try {
+                promise.resolve(block())
+            } catch (e: Throwable) {
+                promise.reject("BILLDOG_ERROR", e.message, e)
+            }
+        }
+    }
+
+    // ── Init ────────────────────────────────────────────────────────────────
+
+    /**
+     * BillDogSurvey.initialize() — surveys are configured by the core
+     * `BillDog.configure(...)`; no per-module native init. Resolve null (no-op).
+     */
+    @ReactMethod
+    fun initialize(promise: Promise) {
+        Log.d(TAG, "initialize() — surveys configured via BillDog.configure(); no-op")
+        promise.resolve(null)
+    }
+
+    /**
+     * BillDogSurvey.presentSurvey(options) → SurveyPresenter.present(surveyId,
+     * activity, handler, customerId, ...) — core SurveyPresenter.present
+     * (SurveyPresenter.kt:23), obtained via BillDog.getSurveyPresenter()
+     * (BillDog.kt:1969). Requires an Activity → reject "NO_ACTIVITY" when null.
+     *
+     * `options.context` and `options.isDismissible` have no native present()
+     * parameter and are ignored (documented). The promise resolves with the
+     * completion SurveyResponse on onComplete, null on onDismiss.
+     */
+    @ReactMethod
+    fun presentSurvey(options: ReadableMap, promise: Promise) {
+        val surveyId = if (options.hasKey("surveyIdentifier")) options.getString("surveyIdentifier") else null
+        if (surveyId.isNullOrBlank()) {
+            promise.reject("INVALID_ARGS", "Missing surveyIdentifier", null)
+            return
+        }
+        val customerId = if (options.hasKey("customerId")) options.getString("customerId") else null
+        val activity: Activity = currentActivity
+            ?: return promise.reject("NO_ACTIVITY", "No Activity available for presentSurvey", null)
+
+        val presenter = BillDog.getSurveyPresenter() // BillDog.kt:1969
+        if (presenter == null) {
+            Log.w(TAG, "presentSurvey($surveyId) — SDK not configured / no survey presenter; resolving null")
+            promise.resolve(null)
+            return
+        }
+
+        val replied = AtomicBoolean(false)
+        val handler = SurveyPresentationHandler(
+            onComplete = { id, result ->
+                if (replied.compareAndSet(false, true)) {
+                    promise.resolve(serializeResponse(id, result))
+                }
+            },
+            onDismiss = {
+                if (replied.compareAndSet(false, true)) {
+                    promise.resolve(null)
+                }
+            },
+            onError = { error ->
+                if (replied.compareAndSet(false, true)) {
+                    promise.reject("BILLDOG_ERROR", error.message, error)
+                }
+            }
+        )
+
+        try {
+            // Resolves to the customVariables/interceptConfig-defaulted overload
+            // (the showUI overload requires a non-default lambda). — SurveyPresenter.kt:23
+            presenter.present(
+                surveyId = surveyId,
+                activity = activity,
+                handler = handler,
+                customerId = customerId
+            )
+        } catch (e: Throwable) {
+            if (replied.compareAndSet(false, true)) {
+                promise.reject("BILLDOG_ERROR", e.message, e)
+            }
+        }
+    }
+
+    /**
+     * BillDogSurvey.fetchSurvey(surveyIdentifier) → SurveyManager.fetchSurvey(
+     * surveyId) — core SurveyManager.fetchSurvey (SurveyManager.kt:32, suspend),
+     * obtained via BillDog.getSurveyManager() (BillDog.kt:2022). Resolves the
+     * serialized SurveyConfig or null when unconfigured.
+     */
+    @ReactMethod
+    fun fetchSurvey(surveyIdentifier: String, promise: Promise) {
+        run(promise) {
+            val mgr = BillDog.getSurveyManager() // BillDog.kt:2022
+                ?: return@run null
+            serializeSurveyConfig(mgr.fetchSurvey(surveyIdentifier)) // SurveyManager.kt:32
+        }
+    }
+
+    /**
+     * BillDogSurvey.submitResponse(response) → SurveyManager.submitSurvey(
+     * surveyId, answers, ...) — core SurveyManager.submitSurvey
+     * (SurveyManager.kt:56, suspend). Returns true on success. Resolves false
+     * when unconfigured (mirrors the JS default).
+     */
+    @ReactMethod
+    fun submitResponse(response: ReadableMap, promise: Promise) {
+        run(promise) {
+            val mgr = BillDog.getSurveyManager() // BillDog.kt:2022
+                ?: return@run false
+            val surveyId = if (response.hasKey("survey_id")) response.getString("survey_id") else null
+            if (surveyId.isNullOrBlank()) return@run false
+            val answers = parseAnswers(if (response.hasKey("answers")) response.getArray("answers") else null)
+            mgr.submitSurvey(surveyId, answers) // SurveyManager.kt:56
+            true
+        }
+    }
+
+    /**
+     * BillDogSurvey.canShowSurvey(surveyIdentifier) — no dedicated native
+     * eligibility API is exposed; the closest PUBLIC signal is
+     * SurveyPresenter.hasCompletedSurvey (SurveyPresenter.kt:91 → standalone :630).
+     * Returns `!hasCompletedSurvey(id)`. NOTE: full display-condition gating
+     * (device/feature-flag/URL/event) is private (`passesGating`) and only
+     * evaluated at present() time, so this is a completion-based proxy, not the
+     * full gating decision. Resolves false when unconfigured (JS default).
+     */
+    @ReactMethod
+    fun canShowSurvey(surveyIdentifier: String, promise: Promise) {
+        run(promise) {
+            val presenter = BillDog.getSurveyPresenter() ?: return@run false // BillDog.kt:1969
+            !presenter.hasCompletedSurvey(surveyIdentifier) // SurveyPresenter.kt:91
+        }
+    }
+
+    // ── NativeEventEmitter plumbing (onSurveyCompleted / onSurveyDismissed) ──
+
+    @ReactMethod
+    fun addListener(eventName: String) { /* NativeEventEmitter bookkeeping — no-op */ }
+
+    @ReactMethod
+    fun removeListeners(count: Int) { /* NativeEventEmitter bookkeeping — no-op */ }
+
+    private fun emit(event: String, params: WritableMap?) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(event, params)
+    }
+
+    // ── Argument parsing ──────────────────────────────────────────────────────
+
+    /**
+     * ReadableArray of JS SurveyAnswer → List<SurveyAnswer>. `answer_json` is
+     * skipped — it is a Map<String, JsonElement> and kotlinx-serialization is
+     * not on this bridge's compile classpath (see class header).
+     */
+    private fun parseAnswers(arr: ReadableArray?): List<SurveyAnswer> {
+        if (arr == null) return emptyList()
+        val out = ArrayList<SurveyAnswer>(arr.size())
+        for (i in 0 until arr.size()) {
+            val m = arr.getMap(i) ?: continue
+            val questionId = if (m.hasKey("question_id")) m.getString("question_id") else null
+            if (questionId.isNullOrBlank()) continue
+            out.add(
+                SurveyAnswer(
+                    question_id = questionId,
+                    choice_id = if (m.hasKey("choice_id")) m.getString("choice_id") else null,
+                    answer_text = if (m.hasKey("answer_text")) m.getString("answer_text") else null,
+                    answer_number = if (m.hasKey("answer_number") && !m.isNull("answer_number"))
+                        m.getDouble("answer_number") else null
+                )
+            )
+        }
+        return out
+    }
+
+    // ── Serializers (plain-field only; JsonElement maps omitted) ─────────────
+
+    /** SurveySubmitResult (SurveyModels.kt:207) → JS SurveyResponse. */
+    private fun serializeResponse(surveyId: String, result: SurveySubmitResult): WritableMap =
+        toWritableMap(mapOf(
+            "survey_id" to surveyId,
+            "respondent_id" to result.respondent_id,
+            "status" to result.status,
+            "answers" to (result.answers?.map { serializeAnswer(it) } ?: emptyList<Any?>())
+        ))
+
+    private fun serializeAnswer(a: SurveyAnswer): Map<String, Any?> = mapOf(
+        "question_id" to a.question_id,
+        "choice_id" to a.choice_id,
+        "answer_text" to a.answer_text,
+        "answer_number" to a.answer_number
+    )
+
+    /** SurveyConfig (SurveyModels.kt:22) → JS Survey. JsonElement `settings` maps omitted. */
+    private fun serializeSurveyConfig(c: SurveyConfig): WritableMap = toWritableMap(mapOf(
+        "id" to c.id,
+        "name" to c.name,
+        "description" to c.description,
+        "type" to c.type,
+        "pages" to c.pages.map { serializePage(it) },
+        "mobile_display" to c.mobile_display?.let { serializeMobileDisplay(it) }
+    ))
+
+    private fun serializePage(p: SurveyPageConfig): Map<String, Any?> = mapOf(
+        "id" to p.id,
+        "title" to p.title,
+        "description" to p.description,
+        "page_order" to p.page_order,
+        "questions" to p.questions.map { serializeQuestion(it) }
+    )
+
+    private fun serializeQuestion(q: SurveyQuestionConfig): Map<String, Any?> = mapOf(
+        "id" to q.id,
+        "type" to q.type,
+        "text" to q.text,
+        "description" to q.description,
+        "is_required" to q.is_required,
+        "question_order" to q.question_order,
+        "choices" to q.choices.map { serializeChoice(it) },
+        "logic_rules" to q.logic_rules.map { serializeLogicRule(it) }
+    )
+
+    private fun serializeChoice(ch: SurveyChoiceConfig): Map<String, Any?> = mapOf(
+        "id" to ch.id,
+        "label" to ch.label,
+        "value" to ch.value,
+        "is_other" to ch.is_other,
+        "choice_order" to ch.choice_order,
+        "image_url" to ch.image_url
+    )
+
+    private fun serializeLogicRule(r: SurveyLogicRule): Map<String, Any?> = mapOf(
+        "id" to r.id,
+        "condition_logic" to r.condition_logic,
+        "action_type" to r.action_type,
+        "target_id" to r.target_id,
+        "rule_order" to r.rule_order
+    )
+
+    private fun serializeMobileDisplay(m: SurveyMobileDisplayConfig): Map<String, Any?> = mapOf(
+        "displayStyle" to m.displayStyle,
+        "allowScrolling" to m.allowScrolling,
+        "interceptBackButton" to m.interceptBackButton,
+        "accessControl" to m.accessControl,
+        "safeAreaInsets" to m.safeAreaInsets,
+        "sheetConfig" to m.sheetConfig?.let {
+            mapOf("heightPercent" to it.heightPercent, "cornerRadius" to it.cornerRadius)
+        },
+        "popupConfig" to m.popupConfig?.let {
+            mapOf("widthPercent" to it.widthPercent, "heightPercent" to it.heightPercent, "cornerRadius" to it.cornerRadius)
+        },
+        "drawerConfig" to m.drawerConfig?.let {
+            mapOf("widthPercent" to it.widthPercent, "cornerRadius" to it.cornerRadius)
+        },
+        "launcherConfig" to m.launcherConfig?.let {
+            mapOf("label" to it.label, "position" to it.position)
+        }
+    )
+
+    // ── Map<String, Any?> → WritableMap converter (private per-module copy) ───
+
+    private fun toWritableMap(map: Map<String, Any?>): WritableMap {
+        val out = Arguments.createMap()
+        for ((key, value) in map) {
+            when (value) {
+                null -> out.putNull(key)
+                is Boolean -> out.putBoolean(key, value)
+                is Int -> out.putInt(key, value)
+                is Long -> out.putDouble(key, value.toDouble())
+                is Float -> out.putDouble(key, value.toDouble())
+                is Double -> out.putDouble(key, value)
+                is String -> out.putString(key, value)
+                is WritableMap -> out.putMap(key, value)
+                is WritableArray -> out.putArray(key, value)
+                is Map<*, *> -> out.putMap(key, toWritableMap(coerceStringKeys(value)))
+                is List<*> -> out.putArray(key, toWritableArray(value))
+                else -> out.putString(key, value.toString())
+            }
+        }
+        return out
+    }
+
+    private fun toWritableArray(list: List<*>): WritableArray {
+        val out = Arguments.createArray()
+        for (value in list) {
+            when (value) {
+                null -> out.pushNull()
+                is Boolean -> out.pushBoolean(value)
+                is Int -> out.pushInt(value)
+                is Long -> out.pushDouble(value.toDouble())
+                is Float -> out.pushDouble(value.toDouble())
+                is Double -> out.pushDouble(value)
+                is String -> out.pushString(value)
+                is WritableMap -> out.pushMap(value)
+                is WritableArray -> out.pushArray(value)
+                is Map<*, *> -> out.pushMap(toWritableMap(coerceStringKeys(value)))
+                is List<*> -> out.pushArray(toWritableArray(value))
+                else -> out.pushString(value.toString())
+            }
+        }
+        return out
+    }
+
+    private fun coerceStringKeys(map: Map<*, *>): Map<String, Any?> =
+        map.entries.associate { (k, v) -> k.toString() to v }
+}