MOBILE-342: Leave the pinned version alone and keep the notes to the public API

The SDK version was only lifted into a variable, not changed — and a branch that
changes nothing about it should not touch the line at all. The two dependencies
the block needs are spelled with the version develop already pins.

The notes stay where a caller reads them: the props, the outcomes and the
component itself. The native sides, the codegen spec and the suite carry none.

Author: Vailence

android/build.gradle

@@ -16,8 +16,6 @@ buildscript {
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
-// After `com.android.library`: the React plugin wires its codegen tasks from the Android library
-// extension, and applying it first leaves the library without them.
 apply plugin: "com.facebook.react"
 
 def getExtOrDefault(name) {
@@ -125,18 +123,11 @@ repositories {
 
 def kotlin_version = getExtOrDefault('kotlinVersion')
 
-// Held next to the SDK version develop already pins, so the two move together.
-def nativeSdkVersion = '2.15.4'
-
 dependencies {
   // noinspection GradleDynamicVersion
   api 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  api "cloud.mindbox:mobile-sdk:$nativeSdkVersion"
-  // The block reads its host screen's lifecycle off the view tree, and this wrapper has to put one
-  // there: React Native's own view lifetime, not the fragment's.
+  api 'cloud.mindbox:mobile-sdk:2.15.4'
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.7"
-  // The SDK keeps mindbox-common an `implementation` dependency, so `@InternalMindboxApi` — the
-  // annotation the embedded block hooks are marked with — is not on the compile classpath without this.
-  compileOnly "cloud.mindbox:mindbox-common:$nativeSdkVersion"
+  compileOnly 'cloud.mindbox:mindbox-common:2.15.4'
 }

android/src/main/java/com/mindboxsdk/embedded/MindboxEmbeddedBlockEvents.kt

@@ -4,16 +4,11 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 
-/**
- * Where the block stands now. A state and not an event: the same value arrives more than once, and the
- * JS side keeps the last one it knew.
- */
 internal class AppearanceChangeEvent(
     surfaceId: Int,
     viewTag: Int,
     private val appearance: String,
 ) : Event<AppearanceChangeEvent>(surfaceId, viewTag) {
-
     override fun getEventName(): String = EVENT_NAME
 
     override fun getEventData(): WritableMap = Arguments.createMap().apply {
@@ -25,9 +20,7 @@ internal class AppearanceChangeEvent(
     }
 }
 
-/** The content is shown. */
 internal class BlockLoadEvent(surfaceId: Int, viewTag: Int) : Event<BlockLoadEvent>(surfaceId, viewTag) {
-
     override fun getEventName(): String = EVENT_NAME
 
     override fun getEventData(): WritableMap = Arguments.createMap()
@@ -37,12 +30,7 @@ internal class BlockLoadEvent(surfaceId: Int, viewTag: Int) : Event<BlockLoadEve
     }
 }
 
-/**
- * The place ended up without content. No payload yet — the reason for the failure is not something the
- * SDK tells apart today, and when it does it lands in this map.
- */
 internal class BlockFailEvent(surfaceId: Int, viewTag: Int) : Event<BlockFailEvent>(surfaceId, viewTag) {
-
     override fun getEventName(): String = EVENT_NAME
 
     override fun getEventData(): WritableMap = Arguments.createMap()

android/src/main/java/com/mindboxsdk/embedded/MindboxEmbeddedBlockHostView.kt

@@ -15,25 +15,10 @@ import cloud.mindbox.mobile_sdk.embedded.MindboxEmbeddedBlockListener
 import cloud.mindbox.mobile_sdk.embedded.MindboxEmbeddedBlockView
 import cloud.mindbox.mobile_sdk.logger.Level
 
-/**
- * The React Native side of one embedded block: a frame that holds the SDK's own container and turns
- * its two signals into RN events.
- *
- * The block itself is the SDK's `MindboxEmbeddedBlockView`, whole and unchanged — the content
- * factory, the waiting budget, the page and its bridge stay on the native side, and RN gets a view to
- * place plus the signals to react to.
- *
- * Why a frame around it rather than the block itself: the SDK block takes its place system name in
- * the constructor, and RN creates a view before it has any props. So the block is built once the
- * props of the first transaction are all in (see [commitProps]) and lives inside this frame.
- */
 @OptIn(InternalMindboxApi::class)
 internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(context) {
-
-    /** Native → RN: where the block stands now, as one of the wire words. */
     var onAppearance: ((String) -> Unit)? = null
 
-    /** Native → RN: how the load ended — `load` or `fail`. */
     var onOutcome: ((String) -> Unit)? = null
 
     private var blockView: MindboxEmbeddedBlockView? = null
@@ -43,22 +28,9 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
     private var hasPlaceholder: Boolean = false
     private var hasErrorView: Boolean = false
 
-    /**
-     * The stand-ins currently handed to the container, kept to tell "the host still draws its own
-     * screen" from "it has just started to".
-     */
     private var placeholderStandIn: View? = null
     private var errorStandIn: View? = null
 
-    /**
-     * The lifecycle the block reads as its host screen's.
-     *
-     * The container gives up for good when the lifecycle owner above it is destroyed — the right rule
-     * for a native screen, and the wrong one here. React Native keeps this view across screens while
-     * `react-native-screens` destroys the fragment of a screen that gets covered: the block would hear
-     * its host die, free its page, and come back to a screen it can no longer load anything for. So the
-     * block is told about the lifetime that actually matters — this view's own.
-     */
     private val hostLifecycleOwner = object : LifecycleOwner {
         val registry: LifecycleRegistry = LifecycleRegistry(this)
 
@@ -71,21 +43,8 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
         setViewTreeLifecycleOwner(hostLifecycleOwner)
     }
 
-    /**
-     * Lays the block out again after React Native has stopped listening.
-     *
-     * Yoga owns layout in RN, so the view groups on the way up answer `requestLayout()` with nothing.
-     * The container swaps its own children as the block resolves — the shimmer for the page, the page
-     * for the failure — and every child added after the last layout pass would stay at zero size: the
-     * page loads, reports its content, and nobody ever sees it. So the frame measures and lays itself
-     * out on the next turn of the looper, with the bounds RN gave it.
-     */
     private val measureAndLayout = Runnable {
         isLayoutScheduled = false
-        // `forceLayout` and not just `measure`: the container swaps a child while RN is already inside
-        // its own layout pass, and that pass clears the flag `requestLayout` had set — a `measure` with
-        // unchanged specs would then return without measuring anything, and the new child would keep
-        // its zero size for good.
         forceLayout()
         measure(
             MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
@@ -96,7 +55,6 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
 
     private var isLayoutScheduled = false
 
-    /** Whether RN has asked for a block at all — the props of the first transaction have landed. */
     private var isBlockWanted = false
 
     override fun requestLayout() {
@@ -111,29 +69,14 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
     }
 
     fun setPlaceSystemName(name: String?) {
-        // Taken exactly as given: the SDK compares names without trimming on every platform, so a
-        // padded name is a name like any other — one that simply never resolves. Filtering it here
-        // would turn that into a block that never settles, which is worse than one that collapses.
         if (name == placeSystemName) {
             return
         }
 
-        // A different place is a different block, and the old one has nothing to hand over. The
-        // wrapper keys the whole component by the place, so this is a safety net and not the usual
-        // path — but a place changed under a live block must not leave the old one running.
         placeSystemName = name
         dropBlock()
     }
 
-    /**
-     * The waiting budget the block is built with, in milliseconds as they came over the wire.
-     *
-     * Zero is the wire word for "the host said nothing" and turns back into the null the SDK
-     * constructor reads as its own default; anything else — a negative included — is handed over as it
-     * is, for the container to sanitize and log. A value that arrives after the block is built goes
-     * nowhere: a running wait cannot be re-budgeted, the JS wrapper both freezes the value and warns,
-     * and this is only the native end of that same rule.
-     */
     fun setTimeoutMs(timeoutMs: Double) {
         if (blockView == null) {
             this.timeoutMs = timeoutMs.takeIf { it != 0.0 }?.toLong()
@@ -167,46 +110,23 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
         syncStandIns()
     }
 
-    /**
-     * The props of a transaction are all in — the block can be built as soon as there is a frame to
-     * build it in.
-     *
-     * Called from here and nowhere else: `createViewInstance` has no props yet, and a single prop
-     * setter would build a block on the place system name while the stand-in flags were still the
-     * defaults.
-     */
     fun commitProps() {
         isBlockWanted = true
         buildBlockIfPossible()
     }
 
-    /**
-     * The frame has bounds now, which is what the block was waiting for.
-     *
-     * A block built before them starts its page in a view of zero size: the page lays itself out
-     * against a zero-width viewport, reports content that occupies nothing, and a later resize does
-     * not make it lay out again — the block reports `onLoad` for a feed nobody can see. RN gives a view
-     * its bounds after the props, so the block waits for them.
-     */
     override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
         super.onSizeChanged(width, height, oldWidth, oldHeight)
         buildBlockIfPossible()
     }
 
-    /**
-     * The container hands out its appearance the moment the observer subscribes — and a place with
-     * nothing behind it settles right there — so subscribing happens before the block ever reaches the
-     * window.
-     */
     private fun buildBlockIfPossible() {
         val place = placeSystemName ?: return
         if (blockView != null || !isBlockWanted || width == 0 || height == 0) {
             return
         }
 
         if (place.isEmpty()) {
-            // Built all the same: the SDK settles a nameless place as empty, so the host hears
-            // `collapsed` and `onFail` instead of watching a placeholder that never resolves.
             Mindbox.writeLog(
                 message = "[EmbeddedBlock] A React Native block was created without a place system name and has nothing to resolve",
                 logLevel = Level.ERROR,
@@ -231,21 +151,13 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
         )
         block.setAppearanceObserver { appearance -> onAppearance?.invoke(nameOf(appearance)) }
 
-        // Last: attaching to the window is what starts the content, and by now everything that has an
-        // opinion about it has been said.
         addView(block, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
     }
 
-    /**
-     * The RN view is gone, so the block's screen is gone with it. Waiting for the host Activity to be
-     * destroyed instead would keep a page loading for a screen nobody can see.
-     */
     fun release() {
         dropBlock()
         onAppearance = null
         onOutcome = null
-        // Now the host screen really is gone, and a block that outlived this call — one the platform
-        // still holds a reference to — has to hear it.
         hostLifecycleOwner.registry.currentState = Lifecycle.State.DESTROYED
     }
 
@@ -261,16 +173,6 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
         removeView(block)
     }
 
-    /**
-     * Puts an empty view where the host draws its own screen — the same arrangement the Compose and
-     * Flutter wrappers use for a slot they cannot hand over directly.
-     *
-     * RN children are real Android views, but the ones above this block belong to Fabric: it mounts
-     * them, and Yoga lays them out. Handing them to the container would take them out of both. So the
-     * container is not given the screen: it is given the fact that the place is taken. That is all it
-     * needs — its own placeholder is held back, and a failed block keeps its height instead of
-     * collapsing. What is actually drawn there is an RN overlay above this frame.
-     */
     private fun syncStandIns() {
         val block = blockView ?: return
 
@@ -297,21 +199,14 @@ internal class MindboxEmbeddedBlockHostView(context: Context) : FrameLayout(cont
 
     private fun makeStandIn(): View = View(context).apply {
         setBackgroundColor(Color.TRANSPARENT)
-        // The stand-in is a placeholder for space, not for touches: what the host drew over it is an
-        // RN view, and it is RN that has to hear the taps on it.
         isClickable = false
         isFocusable = false
     }
 
     private companion object {
-
         const val OUTCOME_LOAD = "load"
         const val OUTCOME_FAIL = "fail"
 
-        /**
-         * Spelled out rather than taken from the enum name: the wire word is a contract with the JS
-         * side, and renaming a case in the SDK must not quietly change it.
-         */
         fun nameOf(appearance: MindboxEmbeddedBlockAppearance): String = when (appearance) {
             MindboxEmbeddedBlockAppearance.PLACEHOLDER -> "placeholder"
             MindboxEmbeddedBlockAppearance.CONTENT -> "content"

android/src/main/java/com/mindboxsdk/embedded/MindboxEmbeddedBlockViewManager.kt

@@ -10,12 +10,10 @@ import com.facebook.react.uimanager.events.Event
 import com.facebook.react.viewmanagers.MindboxEmbeddedBlockViewManagerDelegate
 import com.facebook.react.viewmanagers.MindboxEmbeddedBlockViewManagerInterface
 
-/** The manager of the embedded block component: props in, the block's two signals out. */
 @ReactModule(name = MindboxEmbeddedBlockViewManager.NAME)
 internal class MindboxEmbeddedBlockViewManager :
     SimpleViewManager<MindboxEmbeddedBlockHostView>(),
     MindboxEmbeddedBlockViewManagerInterface<MindboxEmbeddedBlockHostView> {
-
     private val managerDelegate = MindboxEmbeddedBlockViewManagerDelegate(this)
 
     override fun getDelegate(): ViewManagerDelegate<MindboxEmbeddedBlockHostView> = managerDelegate
@@ -37,10 +35,6 @@ internal class MindboxEmbeddedBlockViewManager :
         }
     }
 
-    /**
-     * The block is built here and not in a prop setter: this is the first moment every prop of the
-     * transaction is in, and the container needs the place system name and the stand-in flags together.
-     */
     override fun onAfterUpdateTransaction(view: MindboxEmbeddedBlockHostView) {
         super.onAfterUpdateTransaction(view)
         view.commitProps()
@@ -51,11 +45,6 @@ internal class MindboxEmbeddedBlockViewManager :
         super.onDropViewInstance(view)
     }
 
-    /**
-     * Never recycled. Fabric would hand this frame to another place, and the SDK block inside it cannot
-     * be revived — `release()` is one way. Creating the block with the view and killing it with the view
-     * is what keeps the lifecycle here simple.
-     */
     override fun prepareToRecycleView(
         reactContext: ThemedReactContext,
         view: MindboxEmbeddedBlockHostView,
@@ -65,10 +54,6 @@ internal class MindboxEmbeddedBlockViewManager :
         view.setPlaceSystemName(value)
     }
 
-    /**
-     * Read and ignored: on Android the block is a frame sized by its parent, and here that parent is
-     * RN — the view is laid out to the height the style gives it. The prop exists because iOS needs it.
-     */
     override fun setBlockHeight(view: MindboxEmbeddedBlockHostView, value: Double) = Unit
 
     override fun setTimeoutMs(view: MindboxEmbeddedBlockHostView, value: Double) {