@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/android/src/main/java/com/hydralib/delegates/NonHydraNotificationActivity.kt

@@ -0,0 +1,43 @@
+package com.hydralib.delegates
+
+import android.os.Bundle
+import androidx.annotation.RestrictTo
+import androidx.appcompat.app.AppCompatActivity
+import com.capillary.hydra.android.sdk.utils.Logger
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import com.hydralib.eventemitter.HydraEventEmitter
+import com.hydralib.eventemitter.HydraEventType
+
+class NonHydraNotificationActivity : AppCompatActivity() {
+
+  companion object Companion {
+    private const val TAG = "NonHydraNotificationActivity"
+
+    @RestrictTo(RestrictTo.Scope.LIBRARY)
+    const val EXTRA_REMOTE_MESSAGE = "remote_message"
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    Logger.d(TAG, "NonHydraNotificationActivity created")
+
+    // Extract notification data from intent
+    val remoteMessage = intent.getStringExtra(EXTRA_REMOTE_MESSAGE)
+
+    Logger.d(TAG, "Remote Message: $remoteMessage")
+    val gson = Gson()
+    val type = object : TypeToken<Map<String, Any>>() {}.type
+    val remoteMessageMap = gson.fromJson<Map<String, Any>>(remoteMessage, type)
+
+    // Emit event to React Native
+    HydraEventEmitter.sendEvent(
+      HydraEventType.ON_NON_HYDRA_NOTIFICATION_CLICKED,
+      remoteMessageMap
+    )
+
+    Logger.d(TAG, "Event emitted to React Native: ON_NON_HYDRA_NOTIFICATION_CLICKED")
+    finish()
+  }
+}

package/android/src/main/java/com/hydralib/eventemitter/HydraEventEmitter.kt

@@ -0,0 +1,150 @@
+package com.hydralib.eventemitter
+
+import android.os.Handler
+import android.os.Looper
+import com.capillary.hydra.android.sdk.utils.Logger
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+
+
+// Callback interface for event completion
+fun interface EventResponse {
+  fun onEventResponse(response: Any)
+}
+
+private data class PendingEvent(
+  val body: Any?,
+  val callback: EventResponse?
+)
+
+object HydraEventEmitter {
+  private var emitter: RCTDeviceEventEmitter? = null
+  private val activeEventTypes: ArrayList<HydraEventType> = ArrayList()
+  private val pendingEvents = mutableMapOf<HydraEventType, MutableList<PendingEvent>>()
+  private val eventsWithPendingCallback: ArrayList<PendingEvent> = ArrayList()
+
+
+  fun initialize(reactContext: ReactApplicationContext) {
+    emitter = reactContext.getJSModule(RCTDeviceEventEmitter::class.java)
+  }
+
+  @Synchronized
+  fun sendEvent(eventType: HydraEventType, body: Any?, callback: EventResponse? = null) {
+    if (emitter == null) {
+      var pendingEventsForType: MutableList<PendingEvent>? = pendingEvents[eventType]
+      if (pendingEventsForType == null) {
+        pendingEventsForType = mutableListOf()
+      }
+      pendingEventsForType.add(PendingEvent(body, callback))
+      pendingEvents[eventType] = pendingEventsForType
+
+      Logger.d("HydraEventEmitter.sendEvent", "eventsList for type = ${pendingEvents[eventType]?.toList()}")
+    } else {
+      if (activeEventTypes.contains(eventType)) {
+        Logger.d(
+          "HydraEventEmitter.sendEvent",
+          "sending event for type = ${eventType.event}\n body = $body"
+        )
+        Logger.d("HydraEventEmitter.sendEvent", "java classname of body = ${body?.javaClass?.name}")
+        val processedBody = if (body is Map<*, *>) Arguments.makeNativeMap(
+          convertMapToMutable(body)
+        ) else body
+
+        emitter?.emit(
+          eventType.event,
+          processedBody
+        )
+        if(callback != null) {
+          eventsWithPendingCallback.add(PendingEvent(body, callback))
+        }
+      }
+    }
+  }
+
+  @Synchronized
+  private fun sendPendingEventOfType(eventType: HydraEventType) {
+    Logger.d(
+      "HydraEventEmitter.sendPendingEventOfType",
+      "sendPendingEventOfType called for eventType = ${eventType.event}"
+    )
+    pendingEvents[eventType]?.forEach {
+      sendEvent(eventType, it.body, it.callback)
+    }
+    pendingEvents.remove(eventType)
+  }
+
+  @Synchronized
+  fun addListener(eventName: String?) {
+    Logger.d(
+      "HydraEventEmitter.addListener",
+      "addListener called for eventName = $eventName"
+    )
+    val eventType = HydraEventType.from(eventName!!)
+    if (!activeEventTypes.contains(eventType!!)) {
+      Logger.d(
+        "HydraEventEmitter.addListener",
+        "adding event for eventName = $eventName"
+      )
+      activeEventTypes.add(eventType)
+
+      Logger.d(
+        "HydraEventEmitter.addListener",
+        "sending pending events for eventType = ${eventType.event}"
+      )
+      Handler(Looper.getMainLooper()).postDelayed({
+        sendPendingEventOfType(eventType)
+      }, 300)
+    }
+  }
+
+  @Synchronized
+  fun removeListener(eventName: String?) {
+    Logger.d(
+      "HydraEventEmitter.removeListener",
+      "removeListener called for eventName = $eventName"
+    )
+
+    if (activeEventTypes.contains(HydraEventType.from(eventName!!))) {
+      Logger.d(
+        "HydraEventEmitter.removeListener",
+        "removing event for eventName = $eventName"
+      )
+
+      activeEventTypes.remove(HydraEventType.from(eventName)!!)
+    }
+  }
+
+  private fun convertMapToMutable(originalMap: Map<*, *>): Map<String, Any> {
+    val resultMap = mutableMapOf<String, Any>()
+    originalMap.forEach {
+      if (it.key is String && it.value != null) {
+        resultMap[it.key as String] = it.value!!
+      }
+    }
+    return resultMap
+  }
+
+  @Synchronized
+  fun onSelfHandledInAppResponse(
+    message: ReadableMap?,
+    handled: Boolean,
+   promise: Promise?
+  ) {
+    Logger.d(
+      "HydraEventEmitter.onSelfHandledInAppResponse",
+      "message details - type = $message"
+    )
+    val scope = if (message?.getString("scope") is String) message.getString("scope") as String else "default"
+    for (event in eventsWithPendingCallback) {
+      if (event.body is Map<*, *> && (event.body as Map<*, *>)["scope"] == scope) {
+        event.callback!!.onEventResponse(handled)
+        break
+      }
+    }
+    promise?.resolve(true)
+//    sendEvent(HydraEventType.ON_HYDRA_IN_APP_MESSAGE, detailMap, callback)
+  }
+}

package/android/src/main/java/com/hydralib/eventemitter/HydraEventType.kt

@@ -0,0 +1,44 @@
+package com.hydralib.eventemitter
+
+enum class HydraEventType(val event: String) {
+  ON_TOKEN_AVAILABLE("onTokenAvailable"),
+  ON_NON_HYDRA_NOTIFICATION_RECEIVED("onNonHydraNotificationReceived"),
+  ON_NON_HYDRA_NOTIFICATION_CLICKED("onNonHydraNotificationClicked"),
+  ON_HYDRA_NOTIFICATION_RECEIVED("onHydraNotificationReceived"),
+  ON_HYDRA_NOTIFICATION_CLICKED("onHydraNotificationClicked"),
+  ON_HYDRA_NOTIFICATION_SHOWN("onHydraNotificationShown"),
+  ON_HYDRA_NOTIFICATION_DISMISSED("onHydraNotificationDismissed"),
+  ON_NOTIFICATION_CENTER_DISMISSED("onNotificationCenterDismissed"),
+  ON_INBOX_UPDATED("onInboxUpdated"),
+  HANDLE_CUSTOM_ACTION("handleCustomAction"),
+  ON_HYDRA_SDK_INITIALIZATION_RESULT("onHydraSdkInitializationResult"),
+  ON_HYDRA_IN_APP_MESSAGE("onHydraInAppMessage"),
+  ON_CONFIG_FETCHED_CALLBACK("onConfigFetchedCallback"),
+  ON_LEGACY_FLOW_READY("onLegacyFlowReady"),
+  ON_VISITOR_SESSION_READY("onVisitorSessionReady"),
+  ON_USER_STATE_CHANGED("onUserStateChanged"),
+  ON_GAMIFICATION_VIEW_HEIGHT_CHANGED("onGamificationViewHeightChanged");
+
+  companion object {
+    fun from(eventName: String?): HydraEventType? = when (eventName) {
+      ON_TOKEN_AVAILABLE.event -> ON_TOKEN_AVAILABLE
+      ON_NON_HYDRA_NOTIFICATION_RECEIVED.event  -> ON_NON_HYDRA_NOTIFICATION_RECEIVED
+      ON_NON_HYDRA_NOTIFICATION_CLICKED.event -> ON_NON_HYDRA_NOTIFICATION_CLICKED
+      ON_HYDRA_NOTIFICATION_RECEIVED.event -> ON_HYDRA_NOTIFICATION_RECEIVED
+      ON_HYDRA_NOTIFICATION_CLICKED.event -> ON_HYDRA_NOTIFICATION_CLICKED
+      ON_HYDRA_NOTIFICATION_SHOWN.event -> ON_HYDRA_NOTIFICATION_SHOWN
+      ON_HYDRA_NOTIFICATION_DISMISSED.event -> ON_HYDRA_NOTIFICATION_DISMISSED
+      ON_NOTIFICATION_CENTER_DISMISSED.event -> ON_NOTIFICATION_CENTER_DISMISSED
+      ON_INBOX_UPDATED.event -> ON_INBOX_UPDATED
+      HANDLE_CUSTOM_ACTION.event -> HANDLE_CUSTOM_ACTION
+      ON_HYDRA_SDK_INITIALIZATION_RESULT.event -> ON_HYDRA_SDK_INITIALIZATION_RESULT
+      ON_HYDRA_IN_APP_MESSAGE.event -> ON_HYDRA_IN_APP_MESSAGE
+      ON_CONFIG_FETCHED_CALLBACK.event -> ON_CONFIG_FETCHED_CALLBACK
+      ON_LEGACY_FLOW_READY.event -> ON_LEGACY_FLOW_READY
+      ON_VISITOR_SESSION_READY.event -> ON_VISITOR_SESSION_READY
+      ON_USER_STATE_CHANGED.event -> ON_USER_STATE_CHANGED
+      ON_GAMIFICATION_VIEW_HEIGHT_CHANGED.event -> ON_GAMIFICATION_VIEW_HEIGHT_CHANGED
+      else         -> throw IllegalArgumentException()
+    }
+  }
+}

package/android/src/main/java/com/hydralib/gamification/GamificationBannerViewManager.kt

@@ -0,0 +1,121 @@
+package com.hydralib.gamification
+
+import android.view.View
+import com.capillary.hydra.gamification.model.ContentItem
+import com.capillary.hydra.gamification.model.EntryPointData
+import com.capillary.hydra.gamification.ui.GamificationUIManager
+import com.capillary.hydra.gamification.ui.entrypoints.BannerView
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.hydralib.eventemitter.HydraEventEmitter
+import com.hydralib.eventemitter.HydraEventType
+import com.hydralib.hydrasdk.HydraCore
+
+@ReactModule(name = GamificationBannerViewManager.NAME)
+class GamificationBannerViewManager : SimpleViewManager<BannerView>() {
+
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(context: ThemedReactContext): BannerView =
+    BannerView(HydraCore.curReactActivity ?: context)
+
+  @ReactProp(name = "bannerId")
+  fun setBannerId(view: BannerView, bannerId: String?) {
+    if (bannerId.isNullOrEmpty()) return
+    val data = findEntryPointByBannerId(bannerId) ?: return
+
+    // Defer bind until Yoga has measured and laid out the view
+    if (view.width > 0 && view.height > 0) {
+      bindWithLayout(view, data, bannerId)
+    } else {
+      view.addOnLayoutChangeListener(object : View.OnLayoutChangeListener {
+        override fun onLayoutChange(
+          v: View, left: Int, top: Int, right: Int, bottom: Int,
+          oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int
+        ) {
+          if (right - left > 0 && bottom - top > 0) {
+            view.removeOnLayoutChangeListener(this)
+            bindWithLayout(view, data, bannerId)
+          }
+        }
+      })
+    }
+  }
+
+  /**
+   * Wire callbacks, let BannerView calculate height from dashboard config,
+   * then force a measure/layout pass with the SDK-computed dimensions.
+   *
+   * Height strategy:
+   * - Set layoutParams.height = 0 so BannerView enters SDK-managed path
+   *   and uses dashboard container.height (direct dp value)
+   * - After bind(), BannerView updates layoutParams.height to the computed value
+   * - We read that back, force measure/layout, and emit to RN
+   */
+  private fun bindWithLayout(view: BannerView, data: EntryPointData, bannerId: String) {
+    val w = view.width
+    val activity = HydraCore.curReactActivity
+
+    // Set height to 0 so BannerView.bind() enters SDK-managed path
+    // and calculates height from dashboard container.height (dp)
+    view.layoutParams?.let { lp ->
+      lp.width = w
+      lp.height = 0
+    }
+
+    // Campaign banner lookup — resolves campaignId → CampaignBanner
+    // Required for DYNAMIC_MULTISTEP entry points
+    view.campaignBannerLookup = { campaignId ->
+      HydraCore.getFlowManager()?.getCampaignBanner(campaignId)
+    }
+
+    // Notify server that the entry point was shown
+    view.onEntryPointLoad = { ep ->
+      HydraCore.getFlowManager()?.onEntryPointShown(ep.id, "BANNER")
+    }
+
+    // Handle click — delegates to GamificationUIManager for action routing
+    // (OPEN_DEEPLINK, OPEN_WALLET, OPEN_WEBLINK, campaign opening)
+    view.onEntryPointClick = { ep, contentItem ->
+      if (activity != null) {
+        HydraCore.getGamificationUIManager()?.handleEntryPointAction(activity, ep, contentItem)
+      }
+    }
+
+    view.bind(data)
+
+    // After bind(), BannerView has computed the height from dashboard config
+    // and updated layoutParams.height. Read it back.
+    val sdkHeight = view.layoutParams?.height ?: 0
+    val finalHeight = if (sdkHeight > 0) sdkHeight else view.height
+
+    // Force measure/layout with SDK-computed dimensions — RN parent swallows
+    // requestLayout() so BannerView's internal views never get measured otherwise
+    view.measure(
+      View.MeasureSpec.makeMeasureSpec(w, View.MeasureSpec.EXACTLY),
+      View.MeasureSpec.makeMeasureSpec(finalHeight, View.MeasureSpec.EXACTLY)
+    )
+    view.layout(view.left, view.top, view.left + w, view.top + finalHeight)
+
+    // Emit the SDK-computed height to RN so JS side can update its style
+    if (finalHeight > 0) {
+      val heightDp = finalHeight / view.resources.displayMetrics.density
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_GAMIFICATION_VIEW_HEIGHT_CHANGED,
+        mapOf("height" to heightDp, "entryPointId" to bannerId)
+      )
+    }
+  }
+
+  private fun findEntryPointByBannerId(bannerId: String): EntryPointData? {
+    val flowManager = HydraCore.getFlowManager() ?: return null
+    val entryPoints = flowManager.getFilteredEntryPoints(null)
+    return entryPoints.find { it.mobile?.container?.bannerId == bannerId }
+  }
+
+  companion object {
+    const val NAME = "GamificationBannerView"
+  }
+}

package/android/src/main/java/com/hydralib/gamification/GamificationEmbedViewManager.kt

@@ -0,0 +1,153 @@
+package com.hydralib.gamification
+
+import android.view.View
+import android.view.ViewTreeObserver
+import com.capillary.hydra.gamification.model.EntryPointData
+import com.capillary.hydra.gamification.ui.entrypoints.EmbedWebView
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.hydralib.eventemitter.HydraEventEmitter
+import com.hydralib.eventemitter.HydraEventType
+import com.hydralib.hydrasdk.HydraCore
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+@ReactModule(name = GamificationEmbedViewManager.NAME)
+class GamificationEmbedViewManager : SimpleViewManager<EmbedWebView>() {
+
+  // Tracks the active OnPreDrawListener per view so it can be removed on re-bind/drop
+  // instead of stacking a new listener on top on every setEmbedId call.
+  private val preDrawListeners = mutableMapOf<EmbedWebView, ViewTreeObserver.OnPreDrawListener>()
+
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(context: ThemedReactContext): EmbedWebView =
+    EmbedWebView(HydraCore.curReactActivity ?: context)
+
+  @ReactProp(name = "embedId")
+  fun setEmbedId(view: EmbedWebView, embedId: String?) {
+    if (embedId.isNullOrEmpty()) return
+    // Guard: don't re-bind if already bound to this embedId. Without this, every RN
+    // re-render (triggered by the height-changed event) calls bindWithLayout again and
+    // accumulates an additional OnPreDrawListener, producing an infinite emit loop.
+    if (view.tag == embedId) return
+    val data = findEntryPointByEmbedId(embedId) ?: return
+
+    // Defer bind until Yoga has measured and laid out the view
+    if (view.width > 0 && view.height > 0) {
+      view.tag = embedId
+      bindWithLayout(view, data, embedId)
+    } else {
+      view.addOnLayoutChangeListener(object : View.OnLayoutChangeListener {
+        override fun onLayoutChange(
+          v: View, left: Int, top: Int, right: Int, bottom: Int,
+          oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int
+        ) {
+          if (right - left > 0 && bottom - top > 0) {
+            view.removeOnLayoutChangeListener(this)
+            view.tag = embedId
+            bindWithLayout(view, data, embedId)
+          }
+        }
+      })
+    }
+  }
+
+  /**
+   * Sync layoutParams with Yoga's actual dimensions, wire callbacks, call bind(),
+   * then force a measure/layout pass on the children.
+   */
+  private fun bindWithLayout(view: EmbedWebView, data: EntryPointData, embedId: String) {
+    val w = view.width
+    val h = view.height
+    val activity = HydraCore.curReactActivity ?: return
+
+    // Sync layoutParams with Yoga's actual pixel dimensions
+    // so SDK sees a positive height and takes host-controlled path
+    view.layoutParams?.let { lp ->
+      lp.width = w
+      lp.height = h
+    }
+
+    // Campaign URL lookup — resolves campaignId → campaign WebView URL
+    view.campaignUrlLookup = { campaignId ->
+      HydraCore.getFlowManager()?.getCampaignUrl(campaignId)
+    }
+
+    // Resync after game played
+    view.onGamePlayed = {
+      CoroutineScope(Dispatchers.Main).launch {
+        HydraCore.getFlowManager()?.resync()
+      }
+    }
+
+    // Notify server that the entry point was shown
+    view.onEntryPointLoad = { ep ->
+      HydraCore.getFlowManager()?.onEntryPointShown(ep.id, "EMBEDDED")
+    }
+
+    view.bind(data, activity)
+
+    // Force measure/layout of children — RN parent swallows requestLayout()
+    // so EmbedWebView's internal WebView never gets measured otherwise
+    view.measure(
+      View.MeasureSpec.makeMeasureSpec(w, View.MeasureSpec.EXACTLY),
+      View.MeasureSpec.makeMeasureSpec(h, View.MeasureSpec.EXACTLY)
+    )
+    view.layout(view.left, view.top, view.right, view.bottom)
+
+    // Detect height changes from changeHeight() ValueAnimator.
+    // RN's Yoga parent swallows requestLayout(), so onLayoutChange never fires
+    // when layoutParams.height is updated by the animator. Instead, use
+    // OnPreDrawListener which fires before every draw — the animator drives
+    // draws on each frame, so we can detect layoutParams.height changes here.
+    // Remove any listener from a previous bind before adding a new one — setEmbedId's
+    // tag guard normally prevents re-binding, but this keeps the class correct on its own.
+    preDrawListeners.remove(view)?.let { view.viewTreeObserver.removeOnPreDrawListener(it) }
+
+    var lastEmittedHeight = h
+    val preDrawListener = object : ViewTreeObserver.OnPreDrawListener {
+      override fun onPreDraw(): Boolean {
+        val newHeight = view.layoutParams?.height ?: return true
+        if (newHeight > 0 && newHeight != lastEmittedHeight) {
+          lastEmittedHeight = newHeight
+          val heightDp = newHeight / view.resources.displayMetrics.density
+          HydraEventEmitter.sendEvent(
+            HydraEventType.ON_GAMIFICATION_VIEW_HEIGHT_CHANGED,
+            mapOf("height" to heightDp, "entryPointId" to embedId)
+          )
+
+          // Force re-measure/layout with new dimensions so WebView content
+          // doesn't clip — RN swallows requestLayout()
+          view.measure(
+            View.MeasureSpec.makeMeasureSpec(view.width, View.MeasureSpec.EXACTLY),
+            View.MeasureSpec.makeMeasureSpec(newHeight, View.MeasureSpec.EXACTLY)
+          )
+          view.layout(view.left, view.top, view.left + view.width, view.top + newHeight)
+        }
+        return true
+      }
+    }
+    view.viewTreeObserver.addOnPreDrawListener(preDrawListener)
+    preDrawListeners[view] = preDrawListener
+  }
+
+  private fun findEntryPointByEmbedId(embedId: String): EntryPointData? {
+    val flowManager = HydraCore.getFlowManager() ?: return null
+    val entryPoints = flowManager.getFilteredEntryPoints(null)
+    return entryPoints.find { it.mobile?.container?.bannerId == embedId }
+  }
+
+  override fun onDropViewInstance(view: EmbedWebView) {
+    preDrawListeners.remove(view)?.let { view.viewTreeObserver.removeOnPreDrawListener(it) }
+    view.destroy()
+    super.onDropViewInstance(view)
+  }
+
+  companion object {
+    const val NAME = "GamificationEmbedView"
+  }
+}

package/android/src/main/java/com/hydralib/gamification/GamificationLoyaltyViewManager.kt

@@ -0,0 +1,95 @@
+package com.hydralib.gamification
+
+import android.view.View
+import com.capillary.hydra.gamification.model.LoyaltyUrl
+import com.capillary.hydra.gamification.ui.entrypoints.LoyaltyEmbedView
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.hydralib.hydrasdk.HydraCore
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+@ReactModule(name = GamificationLoyaltyViewManager.NAME)
+class GamificationLoyaltyViewManager : SimpleViewManager<LoyaltyEmbedView>() {
+
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(context: ThemedReactContext): LoyaltyEmbedView =
+    LoyaltyEmbedView(HydraCore.curReactActivity ?: context)
+
+  @ReactProp(name = "loyaltyId")
+  fun setLoyaltyId(view: LoyaltyEmbedView, loyaltyId: String?) {
+    if (loyaltyId.isNullOrEmpty()) return
+    val loyaltyUrl = findLoyaltyUrlById(loyaltyId) ?: return
+
+    // Defer bind until Yoga has measured and laid out the view
+    if (view.width > 0 && view.height > 0) {
+      bindWithLayout(view, loyaltyUrl)
+    } else {
+      view.addOnLayoutChangeListener(object : View.OnLayoutChangeListener {
+        override fun onLayoutChange(
+          v: View, left: Int, top: Int, right: Int, bottom: Int,
+          oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int
+        ) {
+          if (right - left > 0 && bottom - top > 0) {
+            view.removeOnLayoutChangeListener(this)
+            bindWithLayout(view, loyaltyUrl)
+          }
+        }
+      })
+    }
+  }
+
+  /**
+   * Loyalty height strategy: fill whatever RN gives, content scrolls inside.
+   * Same as native Android (MATCH_PARENT × MATCH_PARENT).
+   * No dashboard config, no DIMENSIONS_UPDATE, no dynamic resizing.
+   */
+  private fun bindWithLayout(view: LoyaltyEmbedView, loyaltyUrl: LoyaltyUrl) {
+    val w = view.width
+    val h = view.height
+    val activity = HydraCore.curReactActivity ?: return
+    val flowManager = HydraCore.getFlowManager() ?: return
+
+    // Sync layoutParams with Yoga's actual pixel dimensions
+    view.layoutParams?.let { lp ->
+      lp.width = w
+      lp.height = h
+    }
+
+    // Resync after game played
+    view.onGamePlayed = {
+      CoroutineScope(Dispatchers.Main).launch {
+        HydraCore.getFlowManager()?.resync()
+      }
+    }
+
+    val capToken = flowManager.getCapToken()
+    view.bind(loyaltyUrl.url, capToken, activity)
+
+    // Force measure/layout of children — RN parent swallows requestLayout()
+    // so LoyaltyEmbedView's internal WebView never gets measured otherwise
+    view.measure(
+      View.MeasureSpec.makeMeasureSpec(w, View.MeasureSpec.EXACTLY),
+      View.MeasureSpec.makeMeasureSpec(h, View.MeasureSpec.EXACTLY)
+    )
+    view.layout(view.left, view.top, view.right, view.bottom)
+  }
+
+  private fun findLoyaltyUrlById(loyaltyId: String): LoyaltyUrl? {
+    val flowManager = HydraCore.getFlowManager() ?: return null
+    return flowManager.getLoyaltyUrls().find { it.embedId == loyaltyId }
+  }
+
+  override fun onDropViewInstance(view: LoyaltyEmbedView) {
+    view.destroy()
+    super.onDropViewInstance(view)
+  }
+
+  companion object {
+    const val NAME = "GamificationLoyaltyView"
+  }
+}