pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/screens/Navigator.kt

@@ -0,0 +1,116 @@
+package com.pythonnative.runtime.screens
+
+import android.os.Bundle
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.navigation.NavController
+import androidx.navigation.NavOptions
+import androidx.navigation.fragment.NavHostFragment
+import com.pythonnative.runtime.bridge.PNLog
+
+/**
+ * Stack navigation over the app's `NavHostFragment`. The nav graph is
+ * expected to contain a single fragment destination (the app's
+ * `PNScreenFragment` subclass) taking `screen_path` / `args_json` /
+ * `title` arguments; every push navigates to that destination.
+ */
+object Navigator {
+    /** Locate the `NavHostFragment` anywhere in the activity's fragment tree. */
+    fun navController(activity: FragmentActivity): NavController? {
+        return findNavHost(activity.supportFragmentManager)?.navController
+    }
+
+    private fun findNavHost(fm: FragmentManager): NavHostFragment? {
+        for (fragment in fm.fragments) {
+            if (fragment is NavHostFragment) return fragment
+            val nested = findNavHost(fragment.childFragmentManager)
+            if (nested != null) return nested
+        }
+        return null
+    }
+
+    private fun args(screenPath: String, argsJson: String?, title: String?): Bundle {
+        val bundle = Bundle()
+        bundle.putString(PNScreenFragment.ARG_PATH, screenPath)
+        if (argsJson != null) bundle.putString(PNScreenFragment.ARG_ARGS, argsJson)
+        if (title != null) bundle.putString(PNScreenFragment.ARG_TITLE, title)
+        return bundle
+    }
+
+    @JvmStatic
+    fun push(activity: FragmentActivity, screenPath: String, argsJson: String?, title: String? = null): Boolean {
+        val nav = navController(activity) ?: return false
+        return try {
+            nav.navigate(nav.graph.startDestinationId, args(screenPath, argsJson, title))
+            true
+        } catch (e: Exception) {
+            PNLog.rateLimited("nav-push", "push failed", e)
+            false
+        }
+    }
+
+    @JvmStatic
+    fun pop(activity: FragmentActivity, count: Int = 1): Boolean {
+        val nav = navController(activity) ?: run {
+            activity.finish()
+            return true
+        }
+        var popped = false
+        for (i in 0 until count) {
+            if (!nav.popBackStack()) {
+                if (!popped) activity.finish()
+                break
+            }
+            popped = true
+        }
+        return popped
+    }
+
+    /** Pop everything above the start destination. */
+    @JvmStatic
+    fun popToRoot(activity: FragmentActivity): Boolean {
+        val nav = navController(activity) ?: return false
+        return nav.popBackStack(nav.graph.startDestinationId, false)
+    }
+
+    /** Replace the current screen with a new one (pop current, push new). */
+    @JvmStatic
+    fun replace(activity: FragmentActivity, screenPath: String, argsJson: String?, title: String? = null): Boolean {
+        val nav = navController(activity) ?: return false
+        val current = nav.currentBackStackEntry?.destination?.id ?: nav.graph.startDestinationId
+        return try {
+            val options = NavOptions.Builder().setPopUpTo(current, true).build()
+            nav.navigate(nav.graph.startDestinationId, args(screenPath, argsJson, title), options)
+            true
+        } catch (e: Exception) {
+            PNLog.rateLimited("nav-replace", "replace failed", e)
+            false
+        }
+    }
+
+    /** Rebuild the whole stack from `screens` (`Triple(path, argsJson, title)`). */
+    @JvmStatic
+    fun reset(activity: FragmentActivity, screens: List<Triple<String, String?, String?>>): Boolean {
+        val nav = navController(activity) ?: return false
+        if (screens.isEmpty()) return popToRoot(activity)
+        return try {
+            val root = nav.graph.startDestinationId
+            val (firstPath, firstArgs, firstTitle) = screens[0]
+            val options = NavOptions.Builder().setPopUpTo(root, true).build()
+            nav.navigate(root, args(firstPath, firstArgs, firstTitle), options)
+            for (i in 1 until screens.size) {
+                val (path, argsJson, title) = screens[i]
+                nav.navigate(root, args(path, argsJson, title))
+            }
+            true
+        } catch (e: Exception) {
+            PNLog.rateLimited("nav-reset", "reset failed", e)
+            false
+        }
+    }
+
+    /** The fragment currently shown by the nav host, if any. */
+    fun currentFragment(activity: FragmentActivity): Fragment? =
+        findNavHost(activity.supportFragmentManager)?.childFragmentManager?.primaryNavigationFragment
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/screens/PNScreenFragment.kt

@@ -0,0 +1,223 @@
+package com.pythonnative.runtime.screens
+
+import android.content.pm.ApplicationInfo
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.activity.OnBackPressedCallback
+import androidx.core.os.bundleOf
+import androidx.core.view.ViewCompat
+import androidx.fragment.app.Fragment
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.MainThread
+import com.pythonnative.runtime.bridge.PNLog
+import org.json.JSONObject
+
+/**
+ * The Fragment hosting one PythonNative screen.
+ *
+ * On view creation it asks Python to create the screen
+ * (`callback("host", screenId, "create", {...})`) and afterwards
+ * forwards lifecycle and layout: `start`, `layout`, `resume`, `pause`,
+ * `stop`, `destroy`, `back_pressed`, `save_state`, and
+ * `restore_state`. Python attaches the screen's root view through the
+ * `Host.attach_root` module call, which lands in [attachRoot].
+ *
+ * Apps subclass this (the nav graph names the subclass) and override
+ * [defaultPath] / [defaultDevRoot] to supply the entry module and the
+ * hot-reload root when the fragment arguments don't carry them.
+ */
+open class PNScreenFragment : Fragment() {
+    /** The screen id assigned by [ScreenRegistry]. */
+    var screenId: Int = 0
+        private set
+
+    /** The container the root view is attached into (valid between `onCreateView` and `onDestroyView`). */
+    var container: FrameLayout? = null
+        private set
+
+    private var created = false
+    private var pendingRestore: String? = null
+    private var lastLayout: String? = null
+    private var hotReloadRunning = false
+
+    private val hotReloadRunnable = object : Runnable {
+        override fun run() {
+            if (!hotReloadRunning) return
+            host("hot_reload_tick", "{}")
+            MainThread.postDelayed(this, 500)
+        }
+    }
+
+    /** Screen path when the arguments carry none (apps return the entry module). */
+    protected open fun defaultPath(): String? = null
+
+    /** Hot-reload source root when the arguments carry none (debug builds only). */
+    protected open fun defaultDevRoot(): String? = null
+
+    /** The path this fragment shows. */
+    fun screenPath(): String? = arguments?.getString(ARG_PATH) ?: defaultPath()
+
+    private fun argsJson(): String? = arguments?.getString(ARG_ARGS)
+
+    private fun devRoot(): String? {
+        val explicit = arguments?.getString(ARG_DEV_ROOT)
+        if (explicit != null) return explicit
+        return if (isDebuggable()) defaultDevRoot() else null
+    }
+
+    private fun isDebuggable(): Boolean {
+        val ctx = context ?: return false
+        return (ctx.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        screenId = ScreenRegistry.register(this)
+        pendingRestore = savedInstanceState?.getString(STATE_KEY)
+        requireActivity().onBackPressedDispatcher.addCallback(
+            this,
+            object : OnBackPressedCallback(true) {
+                override fun handleOnBackPressed() {
+                    val consumed = created && host("back_pressed", "{}") == "true"
+                    if (!consumed) {
+                        isEnabled = false
+                        requireActivity().onBackPressedDispatcher.onBackPressed()
+                        isEnabled = true
+                    }
+                }
+            },
+        )
+    }
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+        val frame = FrameLayout(requireContext())
+        frame.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+        this.container = frame
+        return frame
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        arguments?.getString(ARG_TITLE)?.let { activity?.title = it }
+        val payload = JSONObject()
+            .put("path", screenPath() ?: JSONObject.NULL)
+            .put("args", argsJson() ?: JSONObject.NULL)
+            .put("dev_root", devRoot() ?: JSONObject.NULL)
+        host("create", payload.toString())
+        created = true
+        pendingRestore?.let {
+            host("restore_state", JSONObject().put("state", it).toString())
+            pendingRestore = null
+        }
+        view.addOnLayoutChangeListener { v, _, _, _, _, _, _, _, _ -> publishLayout(v) }
+        ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets ->
+            publishLayout(v, force = true)
+            insets
+        }
+        publishLayout(view, force = true)
+        if (devRoot() != null) {
+            hotReloadRunning = true
+            MainThread.remove(hotReloadRunnable)
+            MainThread.postDelayed(hotReloadRunnable, 500)
+        }
+    }
+
+    private fun publishLayout(view: View, force: Boolean = false) {
+        if (!created) return
+        val payload = Viewport.describe(view).toString()
+        if (!force && payload == lastLayout) return
+        lastLayout = payload
+        host("layout", payload)
+    }
+
+    /** Current viewport payload for this screen. */
+    fun viewport(): JSONObject {
+        val v = container ?: view
+        return if (v != null) Viewport.describe(v) else JSONObject()
+    }
+
+    /** Attach `root` (MATCH_PARENT) into the fragment container, replacing any previous root. */
+    fun attachRoot(root: View) {
+        val target = container ?: return
+        target.removeAllViews()
+        (root.parent as? ViewGroup)?.removeView(root)
+        target.addView(root, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        publishLayout(target, force = true)
+    }
+
+    /** Detach `root` from wherever it is parented (never clears the shared container). */
+    fun detachRoot(root: View) {
+        (root.parent as? ViewGroup)?.removeView(root)
+    }
+
+    override fun onStart() {
+        super.onStart()
+        host("start", "{}")
+    }
+
+    override fun onResume() {
+        super.onResume()
+        ScreenRegistry.setActive(screenId)
+        host("resume", viewport().toString())
+    }
+
+    override fun onPause() {
+        super.onPause()
+        host("pause", "{}")
+    }
+
+    override fun onStop() {
+        super.onStop()
+        host("stop", "{}")
+    }
+
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        if (!created) return
+        host("save_state", "{}")?.let { outState.putString(STATE_KEY, it) }
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        hotReloadRunning = false
+        MainThread.remove(hotReloadRunnable)
+        container = null
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        hotReloadRunning = false
+        MainThread.remove(hotReloadRunnable)
+        if (created) host("destroy", "{}")
+        created = false
+        ScreenRegistry.unregister(screenId)
+    }
+
+    private fun host(name: String, payloadJson: String): String? {
+        return try {
+            PNBridge.callPython("host", screenId.toLong(), name, payloadJson)
+        } catch (e: Exception) {
+            PNLog.rateLimited("host:$name", "host callback '$name' failed", e)
+            null
+        }
+    }
+
+    companion object {
+        const val ARG_PATH = "screen_path"
+        const val ARG_ARGS = "args_json"
+        const val ARG_TITLE = "title"
+        const val ARG_DEV_ROOT = "dev_root"
+        private const val STATE_KEY = "pn_screen_state"
+
+        /** Build a fragment for `path` with optional JSON `args` and hot-reload `devRoot`. */
+        @JvmStatic
+        fun newInstance(path: String, argsJson: String?, devRoot: String? = null): PNScreenFragment {
+            val f = PNScreenFragment()
+            f.arguments = bundleOf(ARG_PATH to path, ARG_ARGS to argsJson, ARG_DEV_ROOT to devRoot)
+            return f
+        }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/screens/ScreenRegistry.kt

@@ -0,0 +1,80 @@
+package com.pythonnative.runtime.screens
+
+import android.content.res.Configuration
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.pythonnative.runtime.PNBridge
+import org.json.JSONObject
+import kotlin.math.max
+
+/**
+ * Integer ids for live [PNScreenFragment]s. Python addresses screens
+ * by these ids in `Host` module calls and receives them as the `tag`
+ * of `host` callbacks.
+ */
+object ScreenRegistry {
+    private val screens = LinkedHashMap<Int, PNScreenFragment>()
+    private var nextId = 1
+    private var activeId = 0
+
+    /** Assign an id to `fragment`. */
+    fun register(fragment: PNScreenFragment): Int {
+        val id = nextId++
+        screens[id] = fragment
+        return id
+    }
+
+    fun unregister(id: Int) {
+        screens.remove(id)
+        if (activeId == id) activeId = screens.keys.lastOrNull() ?: 0
+    }
+
+    fun get(id: Int): PNScreenFragment? = screens[id]
+
+    /** Mark `id` as the screen the user currently sees (called on resume). */
+    fun setActive(id: Int) {
+        activeId = id
+    }
+
+    /** The visible screen's id, or `0`. */
+    fun activeId(): Int = activeId
+
+    /** The fragment container of the visible screen (overlay host for `Portal`). */
+    fun activeContainer(): ViewGroup? = screens[activeId]?.container ?: screens.values.lastOrNull()?.container
+}
+
+/** Builds the viewport payload shared by `layout`, `resume`, and `Host.viewport`. */
+object Viewport {
+    /**
+     * `{width, height, insets{top,left,bottom,right}, color_scheme, keyboard_height}`
+     * in dp, measured from `view` (falling back to display metrics when
+     * the view has not been laid out yet).
+     */
+    fun describe(view: View): JSONObject {
+        val density = PNBridge.density()
+        val metrics = view.resources.displayMetrics
+        val w = if (view.width > 0) view.width else metrics.widthPixels
+        val h = if (view.height > 0) view.height else metrics.heightPixels
+        val insets = ViewCompat.getRootWindowInsets(view)
+        val bars = insets?.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
+        val ime = insets?.getInsets(WindowInsetsCompat.Type.ime())
+        val bottomBar = bars?.bottom ?: 0
+        val keyboard = max(0, (ime?.bottom ?: 0) - bottomBar) / density
+        val night = view.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+        return JSONObject()
+            .put("width", w / density.toDouble())
+            .put("height", h / density.toDouble())
+            .put(
+                "insets",
+                JSONObject()
+                    .put("top", (bars?.top ?: 0) / density.toDouble())
+                    .put("left", (bars?.left ?: 0) / density.toDouble())
+                    .put("bottom", bottomBar / density.toDouble())
+                    .put("right", (bars?.right ?: 0) / density.toDouble()),
+            )
+            .put("color_scheme", if (night == Configuration.UI_MODE_NIGHT_YES) "dark" else "light")
+            .put("keyboard_height", keyboard.toDouble())
+    }
+}

pythonnative/templates/android_template/{app/src/main/java/com/pythonnative/android_template → pythonnative/src/main/java/com/pythonnative/runtime/views}/PNAccessibilityDelegate.kt

@@ -1,8 +1,9 @@
-package com.pythonnative.android_template
+package com.pythonnative.runtime.views
 
 import android.os.Build
 import android.view.View
 import android.view.accessibility.AccessibilityNodeInfo
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
 
 /**
  * Accessibility delegate that exposes PythonNative's `test_id` and
@@ -12,9 +13,7 @@ import android.view.accessibility.AccessibilityNodeInfo
  * UI Automator-based tools (Maestro, UiAutomator2, Appium) match as
  * `resource-id`. State flags map onto the closest
  * [AccessibilityNodeInfo] equivalents so TalkBack announces them.
- *
- * Instances are created and configured from Python (the Android view
- * handlers); fields left null are not applied.
+ * Fields left null are not applied.
  */
 class PNAccessibilityDelegate : View.AccessibilityDelegate() {
     var testId: String? = null
@@ -23,6 +22,7 @@ class PNAccessibilityDelegate : View.AccessibilityDelegate() {
     var stateChecked: Boolean? = null
     var stateBusy: Boolean? = null
     var stateExpanded: Boolean? = null
+    var role: String? = null
 
     override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfo) {
         super.onInitializeAccessibilityNodeInfo(host, info)
@@ -33,6 +33,7 @@ class PNAccessibilityDelegate : View.AccessibilityDelegate() {
             info.isCheckable = true
             info.isChecked = it
         }
+        role?.let { AccessibilityNodeInfoCompat.wrap(info).roleDescription = it }
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
             val states = mutableListOf<String>()
             if (stateBusy == true) states.add("busy")

pythonnative/templates/android_template/{app/src/main/java/com/pythonnative/android_template → pythonnative/src/main/java/com/pythonnative/runtime/views}/PNBorderDrawable.kt

@@ -1,4 +1,4 @@
-package com.pythonnative.android_template
+package com.pythonnative.runtime.views
 
 import android.graphics.Canvas
 import android.graphics.ColorFilter
@@ -14,16 +14,25 @@ import android.graphics.drawable.Drawable
  * `GradientDrawable`'s single uniform stroke cannot express.
  *
  * Widths are in pixels; sides are ordered left, top, right, bottom.
+ * The fill color is mutable so animated `background_color` frames can
+ * update it in place without allocating a new drawable.
  */
 class PNBorderDrawable(
-    private val hasBackground: Boolean,
-    private val backgroundColor: Int,
+    private var hasBackground: Boolean,
+    private var backgroundColor: Int,
     private val cornerRadius: Float,
     private val widths: FloatArray,
     private val colors: IntArray,
 ) : Drawable() {
     private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
 
+    /** Replace the fill color (used by animated background frames). */
+    fun setFillColor(color: Int) {
+        hasBackground = true
+        backgroundColor = color
+        invalidateSelf()
+    }
+
     override fun draw(canvas: Canvas) {
         val b = RectF(bounds)
         if (hasBackground) {

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/views/PNEditText.kt

@@ -0,0 +1,18 @@
+package com.pythonnative.runtime.views
+
+import android.content.Context
+import androidx.appcompat.widget.AppCompatEditText
+
+/**
+ * `EditText` that reports selection changes, which the platform only
+ * exposes through a protected override.
+ */
+class PNEditText(context: Context) : AppCompatEditText(context) {
+    /** Called with `(start, end)` whenever the selection or cursor moves. */
+    var onSelectionChangedListener: ((Int, Int) -> Unit)? = null
+
+    override fun onSelectionChanged(selStart: Int, selEnd: Int) {
+        super.onSelectionChanged(selStart, selEnd)
+        onSelectionChangedListener?.invoke(selStart, selEnd)
+    }
+}

pythonnative/templates/android_template/{app/src/main/java/com/pythonnative/android_template → pythonnative/src/main/java/com/pythonnative/runtime/views}/PNFrameLayout.kt

@@ -1,4 +1,4 @@
-package com.pythonnative.android_template
+package com.pythonnative.runtime.views
 
 import android.content.Context
 import android.view.MotionEvent
@@ -6,24 +6,20 @@ import android.widget.FrameLayout
 
 /**
  * Container `FrameLayout` with React Native-style `pointer_events`
- * semantics. Python's Android view handlers create these for flex
- * containers and drive the mode via [setPointerEventsMode]:
+ * semantics. Component managers create these for flex containers and
+ * drive the mode via [setPointerEventsMode]:
  *
  * - `"auto"` (default): normal dispatch; the view and its children
  *   both receive touches.
  * - `"none"`: neither the view nor its children receive touches; the
  *   event falls through to whatever sits underneath.
  * - `"box_none"`: children receive touches, but the view itself never
- *   intercepts or consumes them (the Python side also mutes the
- *   view's own touch listeners).
+ *   intercepts or consumes them (the styler also mutes the view's own
+ *   touch listeners).
  * - `"box_only"`: the view receives touches and its children don't;
  *   every event in the subtree is intercepted at this level.
- *
- * Interception can't be expressed from Python because Chaquopy can't
- * subclass `ViewGroup`, so this class owns the two overrides and
- * exposes the mode as a plain setter.
  */
-class PNFrameLayout(context: Context) : FrameLayout(context) {
+open class PNFrameLayout(context: Context) : FrameLayout(context) {
     private var pointerEventsMode: String = "auto"
 
     /** Set the pointer-events mode; `null` restores `"auto"`. */
@@ -31,6 +27,9 @@ class PNFrameLayout(context: Context) : FrameLayout(context) {
         pointerEventsMode = mode ?: "auto"
     }
 
+    /** The current pointer-events mode. */
+    fun getPointerEventsMode(): String = pointerEventsMode
+
     override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
         if (pointerEventsMode == "none") {
             // Declining the whole dispatch lets the event pass through

pythonnative/templates/android_template/{app/src/main/java/com/pythonnative/android_template → pythonnative/src/main/java/com/pythonnative/runtime/views}/PNVirtualListView.java

@@ -1,4 +1,4 @@
-package com.pythonnative.android_template;
+package com.pythonnative.runtime.views;
 
 import android.content.Context;
 import android.util.TypedValue;
@@ -10,17 +10,15 @@ import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 
 /**
- * RecyclerView-backed virtualized list used by PythonNative's Android bridge.
+ * RecyclerView-backed virtualized list used by PythonNative's VirtualList manager.
  *
- * <p>Chaquopy can proxy Java interfaces from Python, but it can't subclass Java
- * abstract classes such as RecyclerView.Adapter or RecyclerView.ViewHolder. This
- * helper owns those abstract-class implementations in Java and delegates row
- * content back to Python through the small Delegate interface below.</p>
+ * <p>The adapter and view holders live here; row content is delegated to the
+ * {@link Delegate}, which the VirtualList manager implements by asking Python
+ * for a row subtree through the synchronous {@code on_bind_row} protocol.</p>
  *
  * <p>Rows may have per-position heights (section lists interleave headers and
  * items); the delegate reports each row's height in dp. Scroll changes are
- * forwarded to the delegate in dp so the Python side can drive on_scroll,
- * on_end_reached, and viewability callbacks with one code path per platform.</p>
+ * forwarded to the delegate in dp.</p>
  */
 public class PNVirtualListView extends RecyclerView {
     public interface Delegate {
@@ -28,7 +26,7 @@ public class PNVirtualListView extends RecyclerView {
 
         float getRowHeightDp(int position);
 
-        void mountRow(int position, FrameLayout container, float widthDp, float heightDp);
+        void bindRow(int position, FrameLayout container, float widthDp, float heightDp);
 
         void onRowPress(int position);
 
@@ -146,14 +144,13 @@ public class PNVirtualListView extends RecyclerView {
                 params.height = heightPx;
                 holder.container.setLayoutParams(params);
             }
-            holder.container.removeAllViews();
             holder.container.setOnClickListener(v -> {
                 int pos = holder.getBindingAdapterPosition();
                 if (pos != RecyclerView.NO_POSITION) {
                     delegate.onRowPress(pos);
                 }
             });
-            delegate.mountRow(
+            delegate.bindRow(
                 position,
                 holder.container,
                 currentWidthDp(holder.container),
@@ -163,9 +160,9 @@ public class PNVirtualListView extends RecyclerView {
 
         @Override
         public void onViewRecycled(@NonNull RowHolder holder) {
-            holder.container.removeAllViews();
             holder.container.setOnClickListener(null);
             delegate.onRowRecycled(holder.container);
+            holder.container.removeAllViews();
             super.onViewRecycled(holder);
         }
     }