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

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

@@ -0,0 +1,383 @@
+package io.billdog.reactnative
+
+// ─────────────────────────────────────────────────────────────────────────────
+// NOTE ON VERIFICATION
+// This file is compile-ready and internally consistent, but there is NO Android
+// toolchain in the authoring environment. It MUST be built via the react-native
+// example app's Gradle/Android build (`./gradlew :billdog_reactnative:assembleDebug`
+// / a full example RN Android build) to confirm it compiles and that the Compose
+// ViewTree owner wiring behaves correctly inside a React Native (Paper) host view.
+//
+// This is the Paper / legacy (SimpleViewManager, NON-Fabric) implementation of the
+// inline `BDPaywallView`. It is a direct port of the Flutter inline-paywall factory:
+//   packages/flutter/android/src/main/kotlin/io/billdog/flutter/BillDogPaywallViewFactory.kt
+// ─────────────────────────────────────────────────────────────────────────────
+
+import android.app.Activity
+import android.util.Log
+import android.widget.FrameLayout
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ViewModelStoreOwner
+import androidx.lifecycle.setViewTreeLifecycleOwner
+import androidx.lifecycle.setViewTreeViewModelStoreOwner
+import androidx.savedstate.SavedStateRegistryOwner
+import androidx.savedstate.setViewTreeSavedStateRegistryOwner
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import io.billdog.compose.ui.PaywallScreen
+import io.billdog.core.BillDog
+import io.billdog.core.PurchaseResult
+import io.billdog.core.models.PaywallConfiguration
+import io.billdog.core.oauth.OAuthResult
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+/**
+ * React Native (Paper / legacy) view manager for the inline BillDog paywall.
+ *
+ * Exposed to JS as `requireNativeComponent('BDPaywallView')`. Each view instance is
+ * a [FrameLayout] hosting a Jetpack Compose [ComposeView] that renders
+ * [PaywallScreen]. A single manager instance serves every mounted view, so all
+ * per-view state (the [ThemedReactContext], the [ComposeView], and the fetch/
+ * purchase [CoroutineScope]) is keyed off the view in [states].
+ *
+ * Native → JS events are delivered as custom *bubbling* events via
+ * `RCTEventEmitter.receiveEvent(viewId, name, payload)`. The payload shapes match
+ * the Flutter factory (onPurchase {productId, data}, onError {message},
+ * onTrackEvent {event, data}).
+ */
+class BillDogPaywallViewManager : SimpleViewManager<FrameLayout>() {
+
+    override fun getName(): String = REACT_CLASS
+
+    // ── Per-view state ───────────────────────────────────────────────────────
+    // One manager, many views: hold each view's context / ComposeView / scope here
+    // and tear it down in onDropViewInstance.
+    private class ViewState(
+        val reactContext: ThemedReactContext,
+        val composeView: ComposeView,
+    ) {
+        // Scope for the paywall fetch + all subsequent purchase coroutines
+        // (Flutter parity: BillDogPaywallPlatformView.scope, factory:96). Cancelled
+        // in onDropViewInstance.
+        val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+        // Guard so a repeated prop update with the same identifier loads once.
+        var loadedIdentifier: String? = null
+    }
+
+    private val states = mutableMapOf<FrameLayout, ViewState>()
+
+    // ── View lifecycle ────────────────────────────────────────────────────────
+
+    override fun createViewInstance(reactContext: ThemedReactContext): FrameLayout {
+        val frame = FrameLayout(reactContext)
+        val composeView = ComposeView(reactContext).apply {
+            // Flutter parity: dispose when detached (factory:101-103).
+            setViewCompositionStrategy(
+                ViewCompositionStrategy.DisposeOnDetachedFromWindowOrReleasedFromPool
+            )
+            layoutParams = FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT
+            )
+        }
+        frame.addView(composeView)
+        states[frame] = ViewState(reactContext, composeView)
+        return frame
+    }
+
+    override fun onDropViewInstance(view: FrameLayout) {
+        super.onDropViewInstance(view)
+        // Flutter parity: dispose() → scope.cancel() + composeView.disposeComposition()
+        // (factory:275-278).
+        states.remove(view)?.let { state ->
+            state.scope.cancel()
+            state.composeView.disposeComposition()
+        }
+    }
+
+    // ── Props ──────────────────────────────────────────────────────────────────
+
+    /**
+     * `paywallIdentifier` prop. Once non-empty (and not already loading the same id),
+     * install the Compose ViewTree owners from the host Activity and fetch + render
+     * the paywall. Mirrors BillDogPaywallPlatformView.init + loadPaywall (factory:100-160).
+     */
+    @ReactProp(name = "paywallIdentifier")
+    fun setPaywallIdentifier(view: FrameLayout, identifier: String?) {
+        val id = identifier?.takeIf { it.isNotEmpty() } ?: return
+        val state = states[view] ?: return
+        if (state.loadedIdentifier == id) return
+        state.loadedIdentifier = id
+
+        // A ComposeView hosted inside a RN Paper view hierarchy is NOT attached under
+        // a ComponentActivity's content view, so it lacks the ViewTree lifecycle /
+        // savedState / viewModelStore owners Compose requires. Borrow them from the
+        // host Activity (a ComponentActivity implements all three) — Flutter parity
+        // (factory:105-129). We also need the Activity for BillDog.purchase(...).
+        val activity: Activity? = state.reactContext.currentActivity
+        if (activity == null) {
+            emit(view, "onError", mapOf("message" to "No Activity available to host the paywall"))
+            return
+        }
+        if (activity is LifecycleOwner &&
+            activity is SavedStateRegistryOwner &&
+            activity is ViewModelStoreOwner
+        ) {
+            state.composeView.setViewTreeLifecycleOwner(activity)
+            state.composeView.setViewTreeSavedStateRegistryOwner(activity)
+            state.composeView.setViewTreeViewModelStoreOwner(activity)
+        } else {
+            Log.w(
+                TAG,
+                "Host Activity is not a ComponentActivity (LifecycleOwner/" +
+                    "SavedStateRegistryOwner/ViewModelStoreOwner); Compose may fail to attach."
+            )
+        }
+
+        state.scope.launch {
+            try {
+                // Fetch the paywall config WITHOUT presenting it, so we can host it in
+                // this inline container. BillDog.getPaywall is `suspend` and returns a
+                // PaywallConfiguration (BillDog.kt:655) — Flutter parity (factory:140).
+                val config: PaywallConfiguration = BillDog.getPaywall(id)
+
+                // PaywallScreen composable — signature at
+                // billdog-compose/src/main/java/io/billdog/compose/ui/PaywallScreen.kt:335.
+                // onPurchase: (String) -> Unit yields a product id that may be a raw
+                // productId or a component ("comp-") id. Flutter parity (factory:146-153).
+                state.composeView.setContent {
+                    PaywallScreen(
+                        configuration = config,
+                        onDismiss = { emit(view, "onDismiss", null) },
+                        onPurchase = { productId -> handlePurchase(view, state, activity, productId) },
+                        onOAuthResult = { result -> handleOAuth(view, result) }
+                    )
+                }
+                emit(view, "onLoaded", null)
+            } catch (e: Exception) {
+                Log.e(TAG, "getPaywall('$id') failed", e)
+                emit(view, "onError", mapOf("message" to (e.message ?: "Failed to load paywall")))
+            }
+        }
+    }
+
+    // ── Purchase routing ─────────────────────────────────────────────────────
+
+    /**
+     * Resolve `rawId` (possibly a `comp-` component id or blank) to a real store
+     * product id, mirroring PaywallActivity.resolveProductIdentifier (PaywallActivity.kt:571)
+     * and the Flutter factory (factory:169-178). No Offering exists on this inline
+     * path (getPaywall returns config only), so we rely on the static resolution
+     * bridges the renderer populates during selection.
+     */
+    private fun resolveProductIdentifier(rawId: String): String? {
+        // 1. componentId → productIdentifier registry (PaywallActivity.kt:573).
+        io.billdog.core.ProductSelectionBridge.resolveProductId(rawId)?.let { return it }
+        // 2. Live selection recorded by the renderer (PaywallActivity.kt:580).
+        io.billdog.compose.ui.PaywallStateManager
+            .getState<String>("selected_product_id")
+            ?.takeIf { it.isNotEmpty() }
+            ?.let { return it }
+        return null
+    }
+
+    /**
+     * Purchase routing — mirrors PaywallActivity.handlePurchase (PaywallActivity.kt:627)
+     * and the Flutter factory (factory:188-243). A `comp-`-prefixed or blank id is
+     * resolved to a real store product id first; a concrete id is used as-is. The
+     * purchase runs through the Activity-aware entry point
+     * BillDog.purchase(activity, productId) (BillDog.kt:700, suspend), and the outcome
+     * is forwarded to JS as an `onPurchase {productId, data}` event.
+     */
+    private fun handlePurchase(
+        view: FrameLayout,
+        state: ViewState,
+        activity: Activity,
+        productId: String
+    ) {
+        val resolvedProductId = if (productId.startsWith("comp-") || productId.isBlank()) {
+            val resolved = resolveProductIdentifier(productId)
+            if (resolved == null) {
+                Log.e(TAG, "Cannot resolve product identifier from '$productId'")
+                emit(view, "onError", mapOf("message" to "Unable to identify product for purchase"))
+                return
+            }
+            resolved
+        } else {
+            productId
+        }
+
+        state.scope.launch {
+            try {
+                // BillDog.purchase(activity, productId) — BillDog.kt:700 (suspend).
+                val result = BillDog.purchase(activity, resolvedProductId)
+                val data: Map<String, Any?> = when (result) {
+                    is PurchaseResult.Purchased -> mapOf(
+                        "status" to "purchased",
+                        "transactionId" to result.transactionId,
+                        "originalTransactionId" to result.originalTransactionId
+                    )
+                    is PurchaseResult.Restored -> mapOf(
+                        "status" to "restored",
+                        "transactionId" to result.transactionId,
+                        "originalTransactionId" to result.originalTransactionId
+                    )
+                    is PurchaseResult.Cancelled -> mapOf("status" to "cancelled")
+                    is PurchaseResult.Pending -> mapOf("status" to "pending")
+                    is PurchaseResult.Failed -> mapOf(
+                        "status" to "failed",
+                        "error" to result.error.message
+                    )
+                }
+                val effectiveProductId = when (result) {
+                    is PurchaseResult.Purchased -> result.productId
+                    is PurchaseResult.Restored -> result.productId
+                    else -> resolvedProductId
+                }
+                emit(
+                    view,
+                    "onPurchase",
+                    mapOf("productId" to effectiveProductId, "data" to data)
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "purchase('$resolvedProductId') threw", e)
+                emit(view, "onError", mapOf("message" to (e.message ?: "Purchase error")))
+            }
+        }
+    }
+
+    /**
+     * OAuth result routing. PaywallScreen's `onOAuthResult` (PaywallScreen.kt:341)
+     * delivers an [OAuthResult] (fields at OAuthManager.kt). We surface a successful
+     * sign-in as a tracked event onto the JS side; failures are logged. Flutter
+     * parity (factory:250-266).
+     */
+    private fun handleOAuth(view: FrameLayout, result: OAuthResult) {
+        Log.d(TAG, "OAuth result: provider=${result.provider}, success=${result.success}")
+        if (result.success) {
+            emit(
+                view,
+                "onTrackEvent",
+                mapOf(
+                    "event" to "oauth_sign_in",
+                    "data" to mapOf(
+                        "provider" to result.provider.name,
+                        "userId" to result.userId,
+                        "email" to result.email,
+                        "name" to result.name
+                    )
+                )
+            )
+        }
+    }
+
+    // ── Events ───────────────────────────────────────────────────────────────
+
+    /**
+     * Declare the custom bubbling events so RN's UIManager will forward
+     * `on<Event>` props from JSX onto the native `receiveEvent` name.
+     */
+    override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
+        val constants = mutableMapOf<String, Any>()
+        for (event in EVENTS) {
+            constants[event] = mapOf(
+                "phasedRegistrationNames" to mapOf("bubbled" to event)
+            )
+        }
+        return constants
+    }
+
+    /**
+     * Dispatch a native → JS bubbling event for [view]. The [payload] map (or null)
+     * is converted to a [WritableMap] and delivered via
+     * `RCTEventEmitter.receiveEvent(viewId, name, payload)`.
+     */
+    private fun emit(view: FrameLayout, name: String, payload: Map<String, Any?>?) {
+        val reactContext = states[view]?.reactContext ?: return
+        val writable: WritableMap = payload?.let { toWritableMap(it) } ?: Arguments.createMap()
+        reactContext.getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(view.id, name, writable)
+    }
+
+    // ── Map<String, Any?> → WritableMap converter ────────────────────────────
+    // Copied from BillDogModule.kt:729 — RN's Writable* types are the only values
+    // the bridge can send to JS. Recursively converts plain Kotlin maps/lists/scalars.
+    // Longs/Floats are widened to Double (JS number).
+
+    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 }
+
+    companion object {
+        private const val TAG = "BillDogPaywallView"
+        private const val REACT_CLASS = "BDPaywallView"
+
+        // Custom bubbling events surfaced to JS. onDismiss/onPurchase/onLoaded/onError/
+        // onTrackEvent are emitted by this port (matching the Flutter factory).
+        // onRestore/onOpenUrl are declared for JS-prop parity; PaywallScreen surfaces a
+        // restore as an `onPurchase` with a "restored"/"__restore__" outcome, so no
+        // separate native callback exists for them on this inline path.
+        private val EVENTS = listOf(
+            "onLoaded",
+            "onError",
+            "onPurchase",
+            "onDismiss",
+            "onRestore",
+            "onOpenUrl",
+            "onTrackEvent"
+        )
+    }
+}