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

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

@@ -0,0 +1,317 @@
+package io.billdog.reactnative
+
+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.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.abtest.ExperimentAssignment
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * BillDogABTest — React Native native module for Android
+ * (`NativeModules.BillDogABTest`).
+ *
+ * Thin bridge: every `@ReactMethod` here delegates to the concrete A/B-testing
+ * manager (`io.billdog.abtest.BillDogABTest`) resolved per-call from the live
+ * module registry (`BillDog.getModules()` — billdog-core BillDog.kt:427). The
+ * authoritative JS contract is `src/modules/ABTest.ts`; each
+ * `BillDogABTest.<method>(...)` call there maps to the identically-named method
+ * below. When the manager is not registered it resolves to `null` and calls are
+ * best-effort NO-OPs that resolve — matching the JS contract.
+ *
+ * `onExperimentAssignmentChanged` is emitted by subscribing to the SDK EventBus
+ * `AB_VARIANT_ASSIGNED` signal (billdog-core BillDogEventBus.kt:42) that the
+ * manager fires on every fetch (BillDogABTest.kt:258).
+ *
+ * ⚠️ 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 + billdog-ab-test +
+ * kotlinx-coroutines. Every native symbol below is cited to file:line.
+ */
+class BillDogABTestModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val TAG = "BillDogABTest"
+
+    /** suspend getVariant() is launched here; cancelled in invalidate(). */
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    /** EventBus subscription id for AB_VARIANT_ASSIGNED; unsubscribed in invalidate(). */
+    private var assignmentSubscription: String? = null
+
+    override fun getName(): String = "BillDogABTest"
+
+    init {
+        // Bridge the SDK EventBus AB_VARIANT_ASSIGNED signal → RN
+        // `onExperimentAssignmentChanged`. subscribe() — BillDogEventBus.kt:77.
+        assignmentSubscription = BillDogEventBus.subscribe(
+            BillDogEventBus.EventTypes.AB_VARIANT_ASSIGNED // BillDogEventBus.kt:42
+        ) { event ->
+            val experimentId = event.properties["experiment_id"]?.toString() ?: return@subscribe
+            // Resolve the full assignment for the RN payload; fall back to the
+            // thin {experiment_id, variant_id} the event itself carries.
+            val assignment = abtest()?.getVariantSync(experimentId) // BillDogABTest.kt:171
+            val payload = if (assignment != null) {
+                serializeAssignment(assignment)
+            } else {
+                toWritableMap(mapOf(
+                    "experimentId" to experimentId,
+                    "variantId" to (event.properties["variant_id"]?.toString() ?: "")
+                ))
+            }
+            emit("onExperimentAssignmentChanged", payload)
+        }
+    }
+
+    // ── Lifecycle ──────────────────────────────────────────────────────────
+
+    override fun invalidate() {
+        assignmentSubscription?.let { BillDogEventBus.unsubscribe(it) } // BillDogEventBus.kt:84
+        scope.cancel()
+        super.invalidate()
+    }
+
+    @Deprecated("Deprecated in RN; kept for older RN versions that call it instead of invalidate()")
+    override fun onCatalystInstanceDestroy() {
+        assignmentSubscription?.let { BillDogEventBus.unsubscribe(it) }
+        scope.cancel()
+        @Suppress("DEPRECATION")
+        super.onCatalystInstanceDestroy()
+    }
+
+    /** Resolve the concrete A/B manager from the live registry; null → callers NO-OP. */
+    private fun abtest(): io.billdog.abtest.BillDogABTest? =
+        BillDog.getModules() // billdog-core BillDog.kt:427
+            .firstOrNull { it is io.billdog.abtest.BillDogABTest }
+            as? io.billdog.abtest.BillDogABTest
+
+    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 ────────────────────────────────────────────────────────────────
+
+    /**
+     * BillDogABTest.initialize() — the A/B manager is configured by the core
+     * `BillDog.configure(...)`; there is no per-module native init. Resolve null
+     * (documented no-op).
+     */
+    @ReactMethod
+    fun initialize(promise: Promise) {
+        Log.d(TAG, "initialize() — ABTest configured via BillDog.configure(); no-op")
+        promise.resolve(null)
+    }
+
+    /**
+     * BillDogABTest.getVariant(experimentId) → mgr.getVariant(experimentId)
+     * — BillDogABTest.kt:166 (suspend; joins the in-flight fetch). Returns the
+     * serialized ExperimentAssignment or null.
+     */
+    @ReactMethod
+    fun getVariant(experimentId: String, promise: Promise) {
+        run(promise) {
+            abtest()?.getVariant(experimentId)?.let { serializeAssignment(it) } // :166
+        }
+    }
+
+    /**
+     * BillDogABTest.trackConversion(experimentId, value, metadata) →
+     * mgr.trackConversion(experimentId, value, metadata) — BillDogABTest.kt:206.
+     * JS always passes value (default 1) and metadata (default {}).
+     */
+    @ReactMethod
+    @Suppress("UNCHECKED_CAST")
+    fun trackConversion(experimentId: String, value: Double, metadata: ReadableMap?, promise: Promise) {
+        run(promise) {
+            abtest()?.trackConversion(
+                experimentId,
+                value,
+                (metadata?.toHashMap() as? Map<String, Any>) ?: emptyMap()
+            ) // :206
+            null
+        }
+    }
+
+    /** BillDogABTest.trackImpression(experimentId) → mgr.trackImpression(experimentId) — BillDogABTest.kt:236. */
+    @ReactMethod
+    fun trackImpression(experimentId: String, promise: Promise) {
+        run(promise) { abtest()?.trackImpression(experimentId); null } // :236
+    }
+
+    /**
+     * BillDogABTest.setUserId(id) → mgr.setUserId(id) — BillDogABTest.kt:284
+     * (triggers an automatic experiment refresh internally).
+     */
+    @ReactMethod
+    fun setUserId(id: String, promise: Promise) {
+        run(promise) { abtest()?.setUserId(id); null } // :284
+    }
+
+    /** BillDogABTest.setAttributes(attributes) → mgr.setAttributes(attributes) — BillDogABTest.kt:290. */
+    @ReactMethod
+    @Suppress("UNCHECKED_CAST")
+    fun setAttributes(attributes: ReadableMap?, promise: Promise) {
+        run(promise) {
+            abtest()?.setAttributes((attributes?.toHashMap() as? Map<String, Any>) ?: emptyMap()) // :290
+            null
+        }
+    }
+
+    /**
+     * BillDogABTest.getFeatureFlag(key) → mgr.getFeatureFlag(key) —
+     * BillDogABTest.kt:179 (Boolean; unknown keys fail-closed to false). JS types
+     * the return as `any`; a boolean satisfies it.
+     */
+    @ReactMethod
+    fun getFeatureFlag(key: String, promise: Promise) {
+        run(promise) { abtest()?.getFeatureFlag(key) ?: false } // :179
+    }
+
+    /** BillDogABTest.refreshExperiments() → mgr.refreshExperiments() — BillDogABTest.kt:161. */
+    @ReactMethod
+    fun refreshExperiments(promise: Promise) {
+        run(promise) { abtest()?.refreshExperiments(); null } // :161
+    }
+
+    /** BillDogABTest.reset() → mgr.reset() — BillDogABTest.kt:265. */
+    @ReactMethod
+    fun reset(promise: Promise) {
+        run(promise) { abtest()?.reset(); null } // :265
+    }
+
+    // ── NativeEventEmitter plumbing (onExperimentAssignmentChanged) ──────────
+
+    @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)
+    }
+
+    // ── Serializers ──────────────────────────────────────────────────────────
+
+    /** io.billdog.abtest.ExperimentAssignment (BillDogABTest.kt:383) → JS ExperimentAssignment. */
+    private fun serializeAssignment(a: ExperimentAssignment): WritableMap = toWritableMap(mapOf(
+        "experimentId" to a.experimentId,
+        "variantId" to a.variantId,
+        "variantName" to a.variantName,
+        "config" to a.config,
+        "isControl" to a.isControl
+    ))
+
+    // ── Map<String, Any?> → WritableMap converter (private per-module copy) ───
+    // Handles org.json values because ExperimentAssignment.config stores raw
+    // JSONObject/JSONArray/primitives decoded from the experiment-config payload.
+
+    private fun toWritableMap(map: Map<String, Any?>): WritableMap {
+        val out = Arguments.createMap()
+        for ((key, value) in map) {
+            when (value) {
+                null, JSONObject.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 JSONObject -> out.putMap(key, jsonObjectToWritable(value))
+                is JSONArray -> out.putArray(key, jsonArrayToWritable(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, JSONObject.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 JSONObject -> out.pushMap(jsonObjectToWritable(value))
+                is JSONArray -> out.pushArray(jsonArrayToWritable(value))
+                is Map<*, *> -> out.pushMap(toWritableMap(coerceStringKeys(value)))
+                is List<*> -> out.pushArray(toWritableArray(value))
+                else -> out.pushString(value.toString())
+            }
+        }
+        return out
+    }
+
+    private fun jsonObjectToWritable(obj: JSONObject): WritableMap {
+        val out = Arguments.createMap()
+        val keys = obj.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            when (val v = obj.get(key)) {
+                JSONObject.NULL -> out.putNull(key)
+                is Boolean -> out.putBoolean(key, v)
+                is Int -> out.putInt(key, v)
+                is Long -> out.putDouble(key, v.toDouble())
+                is Double -> out.putDouble(key, v)
+                is String -> out.putString(key, v)
+                is JSONObject -> out.putMap(key, jsonObjectToWritable(v))
+                is JSONArray -> out.putArray(key, jsonArrayToWritable(v))
+                else -> out.putString(key, v.toString())
+            }
+        }
+        return out
+    }
+
+    private fun jsonArrayToWritable(arr: JSONArray): WritableArray {
+        val out = Arguments.createArray()
+        for (i in 0 until arr.length()) {
+            when (val v = arr.get(i)) {
+                JSONObject.NULL -> out.pushNull()
+                is Boolean -> out.pushBoolean(v)
+                is Int -> out.pushInt(v)
+                is Long -> out.pushDouble(v.toDouble())
+                is Double -> out.pushDouble(v)
+                is String -> out.pushString(v)
+                is JSONObject -> out.pushMap(jsonObjectToWritable(v))
+                is JSONArray -> out.pushArray(jsonArrayToWritable(v))
+                else -> out.pushString(v.toString())
+            }
+        }
+        return out
+    }
+
+    private fun coerceStringKeys(map: Map<*, *>): Map<String, Any?> =
+        map.entries.associate { (k, v) -> k.toString() to v }
+}