react-native-list 1.0.0 → 2.0.0-alpha.1

package/android/src/main/java/com/margelo/nitro/reactnativelist/HybridUiListView.kt

@@ -0,0 +1,410 @@
+package com.margelo.nitro.reactnativelist
+
+import android.graphics.Color
+import android.graphics.Canvas
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.facebook.react.ReactActivity
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.interfaces.fabric.ReactSurface
+import com.facebook.react.runtime.ReactSurfaceView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.margelo.nitro.NitroModules
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.atomic.AtomicReference
+
+typealias CreateViewCallbackType = (
+    type: String
+) -> Double
+typealias UpdateViewCallbackType = (
+    reactTag: Double,
+    item: NativeListItem,
+    index: Double
+) -> Boolean
+
+class HybridUiListView(val reactContext: ThemedReactContext) :
+    HybridUiListViewSpec(),
+    NativeListDataSourceObserver {
+    private var createViewCallback: CreateViewCallbackType? = null
+    private var updateViewCallback: UpdateViewCallbackType? = null
+    private var adapter: NativeListAdapter? = null
+    private var dataSource: HybridNativeListDataSource? = null
+    private var isRecyclerViewLayoutScheduled = false
+    private var itemContentInsets = ItemContentInsets(horizontal = 0, vertical = 0)
+    private var rendererSurface: ReactSurface? = null
+    private var rendererSurfaceId: Int? = null
+    private var isRendererSurfaceStarted = false
+    private var isDisposed = false
+
+    override val view: RecyclerView by lazy {
+        ClippedRecyclerView(reactContext).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+            layoutManager = LinearLayoutManager(reactContext)
+            setBackgroundColor(Color.TRANSPARENT)
+        }
+    }
+
+    override fun setListCallbacks(
+        uiListModule: HybridUiListModuleSpec,
+        createView: CreateViewCallbackType,
+        updateView: UpdateViewCallbackType
+    ) {
+        isDisposed = false
+        createViewCallback = createView
+        updateViewCallback = updateView
+        runOnMain {
+            ensureAdapter()
+        }
+    }
+
+    override fun getSurfaceId(): Double {
+        val surfaceId = runOnMainSync {
+            ensureRendererSurface()
+        }
+        return surfaceId.toDouble()
+    }
+
+    override fun disposeRendererSurface() {
+        runOnMainSync {
+            isDisposed = true
+            createViewCallback = null
+            updateViewCallback = null
+            dataSource?.observer = null
+            dataSource = null
+            adapter?.dataSource = null
+            adapter = null
+            // setAdapter(null) asks RecyclerView to recycle attached holders immediately.
+            // During list teardown the whole native view is going away, so drop the adapter
+            // without entering RecyclerView's recycling path.
+            view.swapAdapter(null, false)
+            view.layoutManager?.removeAllViews()
+            isRecyclerViewLayoutScheduled = false
+
+            val surface = rendererSurface
+            rendererSurface = null
+            rendererSurfaceId = null
+            isRendererSurfaceStarted = false
+
+            if (surface == null) {
+                return@runOnMainSync
+            }
+
+            surface.stop()
+            surface.clear()
+            surface.detach()
+        }
+    }
+
+    override fun onDropView() {
+        disposeRendererSurface()
+        super.onDropView()
+    }
+
+    override fun setDataSource(dataSource: HybridNativeListDataSourceSpec) {
+        val nativeDataSource = dataSource as? HybridNativeListDataSource
+            ?: throw IllegalStateException("NativeListDataSource must be created by react-native-list.")
+
+        runOnMain {
+            val existingDataSource = this.dataSource
+            if (existingDataSource === nativeDataSource) {
+                return@runOnMain
+            }
+
+            this.dataSource?.observer = null
+            this.dataSource = nativeDataSource
+            nativeDataSource.observer = this
+            val nativeAdapter = ensureAdapter()
+            nativeAdapter.dataSource = nativeDataSource
+            nativeAdapter.retainMeasuredContent(nativeDataSource)
+            nativeAdapter.notifyDataSetChanged()
+            scheduleRecyclerViewLayout()
+        }
+    }
+
+    override fun setLayout(layout: HybridNativeListLayoutSpec) {
+        val layoutProvider = layout as? NativeListLayoutProvider
+            ?: throw IllegalStateException("NativeListLayout must provide a platform layout.")
+
+        runOnMain {
+            itemContentInsets = layoutProvider.itemContentInsets(reactContext)
+            val nativeAdapter = adapter
+            if (nativeAdapter != null) {
+                nativeAdapter.itemContentInsets = itemContentInsets
+                nativeAdapter.notifyDataSetChanged()
+            }
+            layoutProvider.applyTo(view, reactContext)
+            scheduleRecyclerViewLayout()
+        }
+    }
+
+    override fun dataSourceDidReload(diffResult: DiffUtil.DiffResult?, animated: Boolean) {
+        runOnMain {
+            val nativeAdapter = ensureAdapter()
+            val nativeDataSource = dataSource
+            if (nativeDataSource != null) {
+                nativeAdapter.retainMeasuredContent(nativeDataSource)
+            }
+
+            if (!animated || diffResult == null) {
+                nativeAdapter.notifyDataSetChanged()
+                scheduleRecyclerViewLayout()
+                return@runOnMain
+            }
+
+            diffResult.dispatchUpdatesTo(nativeAdapter)
+            scheduleRecyclerViewLayout()
+        }
+    }
+
+    override fun dataSourceDidInsert(index: Int) {
+        runOnMain {
+            val nativeAdapter = ensureAdapter()
+            nativeAdapter.notifyItemInserted(index)
+            scheduleRecyclerViewLayout()
+        }
+    }
+
+    override fun dataSourceDidUpdate(index: Int, previousItem: NativeListItem) {
+        runOnMain {
+            val nativeAdapter = ensureAdapter()
+            nativeAdapter.notifyItemChanged(index)
+            scheduleRecyclerViewLayout()
+        }
+    }
+
+    override fun dataSourceDidRemove(index: Int, removedItem: NativeListItem) {
+        runOnMain {
+            val nativeAdapter = ensureAdapter()
+            nativeAdapter.notifyItemRemoved(index)
+            scheduleRecyclerViewLayout()
+        }
+    }
+
+    override fun dataSourceDidMove(fromIndex: Int, toIndex: Int) {
+        runOnMain {
+            val nativeAdapter = ensureAdapter()
+            nativeAdapter.notifyItemMoved(fromIndex, toIndex)
+            scheduleRecyclerViewLayout()
+        }
+    }
+
+    private fun ensureAdapter(): NativeListAdapter {
+        if (isDisposed) {
+            throw IllegalStateException("Cannot create adapter after list was disposed.")
+        }
+
+        val existingAdapter = adapter
+        if (existingAdapter != null) {
+            return existingAdapter
+        }
+
+        val nativeAdapter = NativeListAdapter(
+            reactContext = reactContext,
+            createView = { type ->
+                createNativeView(type)
+            },
+            updateView = { reactTag, item, index ->
+                val capturedCallback = updateViewCallback
+                    ?: throw IllegalStateException("UpdateView callback is not set.")
+                capturedCallback(reactTag, item, index)
+            }
+        )
+        nativeAdapter.itemContentInsets = itemContentInsets
+        nativeAdapter.dataSource = dataSource
+        adapter = nativeAdapter
+        attachAdapterIfRendererReady()
+        return nativeAdapter
+    }
+
+    private fun attachAdapterIfRendererReady() {
+        val nativeAdapter = adapter
+            ?: return
+
+        val surfaceId = rendererSurfaceId
+        if (surfaceId != null && !isRendererSurfaceStarted) {
+            return
+        }
+
+        val currentAdapter = view.adapter
+        if (currentAdapter === nativeAdapter) {
+            return
+        }
+
+        view.adapter = nativeAdapter
+    }
+
+    private fun ensureRendererSurface(): Int {
+        val existingSurfaceId = rendererSurfaceId
+        if (existingSurfaceId != null) {
+            return existingSurfaceId
+        }
+
+        val context: ReactApplicationContext = NitroModules.applicationContext
+            ?: throw IllegalStateException("ReactApplicationContext is null! Is Nitro installed?")
+        val reactActivity = context.currentActivity as? ReactActivity
+            ?: throw IllegalStateException("Current activity is not a ReactActivity!")
+        val reactHost = reactActivity.reactActivityDelegate.reactHost
+            ?: throw IllegalStateException("ReactNativeHost is null!")
+
+        val surface = reactHost.createSurface(reactContext, "", null)
+        val surfaceView = surface.view as? ReactSurfaceView
+            ?: throw IllegalStateException("Surface view is not a ReactSurfaceView!")
+        val surfaceId = surfaceView.getRootViewTag()
+
+        rendererSurface = surface
+        rendererSurfaceId = surfaceId
+        isRendererSurfaceStarted = false
+        isDisposed = false
+
+        val startTask = surface.start()
+        val waitThread = Thread {
+            try {
+                startTask.waitForCompletion()
+                view.post {
+                    val startError = startTask.getError()
+                    if (startError != null) {
+                        throw startError
+                    }
+
+                    if (isDisposed) {
+                        return@post
+                    }
+
+                    val currentSurfaceId = rendererSurfaceId
+                    if (currentSurfaceId != surfaceId) {
+                        return@post
+                    }
+
+                    isRendererSurfaceStarted = true
+                    attachAdapterIfRendererReady()
+                    scheduleRecyclerViewLayout()
+                }
+            } catch (throwable: Throwable) {
+                view.post {
+                    throw throwable
+                }
+            }
+        }
+        waitThread.name = "UiListSurfaceStart-$surfaceId"
+        waitThread.start()
+
+        return surfaceId
+    }
+
+    private fun createNativeView(type: String): View {
+        if (isDisposed) {
+            throw IllegalStateException("Cannot create view after list was disposed.")
+        }
+
+        val capturedCallback = createViewCallback
+            ?: throw IllegalStateException("CreateView callback is not set.")
+
+        val viewTag = capturedCallback(type).toInt()
+        val fabricUiManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+            ?: throw IllegalStateException("Fabric UIManager is null. Is Fabric enabled?")
+
+        val resolvedView = fabricUiManager.resolveView(viewTag)
+            ?: throw IllegalStateException("Could not resolve view with tag $viewTag.")
+
+        val parent = resolvedView.parent as? ViewGroup
+            ?: throw IllegalStateException("View with tag $viewTag has no parent.")
+        val childIndex = parent.indexOfChild(resolvedView)
+        parent.removeViewAt(childIndex)
+
+        if (resolvedView.parent != null) {
+            throw IllegalStateException("View with tag $viewTag still has a parent after removing.")
+        }
+
+        parent.addView(View(reactContext), childIndex)
+
+        return resolvedView
+    }
+
+    private fun scheduleRecyclerViewLayout() {
+        val surfaceId = rendererSurfaceId
+        if (surfaceId != null && !isRendererSurfaceStarted) {
+            return
+        }
+
+        if (isRecyclerViewLayoutScheduled) {
+            return
+        }
+
+        isRecyclerViewLayoutScheduled = true
+        view.post {
+            isRecyclerViewLayoutScheduled = false
+            performRecyclerViewLayoutIfReady()
+        }
+    }
+
+    private fun performRecyclerViewLayoutIfReady() {
+        val viewWidth = view.width
+        val viewHeight = view.height
+        if (!view.isAttachedToWindow || viewWidth <= 0 || viewHeight <= 0) {
+            return
+        }
+
+        // React Native has already assigned bounds, but RecyclerView requestLayout()
+        // is not always traversed from this Fabric-hosted view. Drive RecyclerView's
+        // pending adapter updates with the current RN layout.
+        val widthSpec = View.MeasureSpec.makeMeasureSpec(viewWidth, View.MeasureSpec.EXACTLY)
+        val heightSpec = View.MeasureSpec.makeMeasureSpec(viewHeight, View.MeasureSpec.EXACTLY)
+        view.measure(widthSpec, heightSpec)
+        view.layout(view.left, view.top, view.right, view.bottom)
+    }
+
+    private fun runOnMain(block: () -> Unit) {
+        val isMainThread = Looper.myLooper() == Looper.getMainLooper()
+        if (isMainThread) {
+            block()
+        } else {
+            view.post(block)
+        }
+    }
+
+    private fun <T> runOnMainSync(block: () -> T): T {
+        val isMainThread = Looper.myLooper() == Looper.getMainLooper()
+        if (isMainThread) {
+            return block()
+        }
+
+        val result = AtomicReference<Result<T>>()
+        val latch = CountDownLatch(1)
+        view.post {
+            try {
+                val value = block()
+                result.set(Result.success(value))
+            } catch (throwable: Throwable) {
+                result.set(Result.failure(throwable))
+            } finally {
+                latch.countDown()
+            }
+        }
+        latch.await()
+        val capturedResult = result.get()
+            ?: throw IllegalStateException("UI thread did not return a result.")
+        return capturedResult.getOrThrow()
+    }
+
+    private class ClippedRecyclerView(context: ThemedReactContext) : RecyclerView(context) {
+        override fun dispatchDraw(canvas: Canvas) {
+            // RN/Fabric parents may allow child drawing outside their bounds.
+            // Keep clipToPadding=false for list insets, but clip rows to the list viewport.
+            // Without this item could overflow the list bounds.
+            val saveCount = canvas.save()
+            canvas.clipRect(0, 0, width, height)
+            super.dispatchDraw(canvas)
+            canvas.restoreToCount(saveCount)
+        }
+    }
+
+}

package/android/src/main/java/com/margelo/nitro/reactnativelist/HybridViewHolder.kt

@@ -0,0 +1,9 @@
+package com.margelo.nitro.reactnativelist
+
+import android.view.View
+import com.facebook.react.uimanager.ThemedReactContext
+
+class HybridViewHolder(context: ThemedReactContext) : HybridViewHolderSpec() {
+    override val view: View
+        get() = TODO("Hm, would this here be the user's view?")
+}

package/android/src/main/java/com/margelo/nitro/reactnativelist/NativeListAdapter.kt

@@ -0,0 +1,217 @@
+package com.margelo.nitro.reactnativelist
+
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.recyclerview.widget.RecyclerView
+import com.facebook.react.uimanager.ThemedReactContext
+import kotlin.math.roundToInt
+
+internal class NativeListAdapter(
+    private val reactContext: ThemedReactContext,
+    private val createView: (type: String) -> View,
+    private val updateView: (reactTag: Double, item: NativeListItem, index: Double) -> Boolean
+) : RecyclerView.Adapter<NativeListAdapter.ViewHolder>() {
+
+    var dataSource: HybridNativeListDataSource? = null
+    private val viewTypeByItemType = mutableMapOf<String, Int>()
+    private val itemTypeByViewType = mutableMapOf<Int, String>()
+    private val measuredContentSizeByItemKey = mutableMapOf<String, PixelSize>()
+    private var nextViewType = 1
+    var itemContentInsets = ItemContentInsets(horizontal = 0, vertical = 0)
+
+    class ViewHolder(val container: FrameLayout) : RecyclerView.ViewHolder(container) {
+        var hostedView: View? = null
+        var itemType: String? = null
+        var reactTag: Int? = null
+    }
+
+    private data class PixelSize(
+        val width: Int?,
+        val height: Int?
+    )
+
+    private data class ResolvedPixelSize(
+        val width: Int,
+        val height: Int
+    )
+
+    override fun getItemViewType(position: Int): Int {
+        val item = requireDataSource().getItemAt(position)
+        val existingViewType = viewTypeByItemType[item.type]
+        if (existingViewType != null) {
+            return existingViewType
+        }
+
+        val viewType = nextViewType
+        nextViewType += 1
+        viewTypeByItemType[item.type] = viewType
+        itemTypeByViewType[viewType] = item.type
+        return viewType
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val container = FrameLayout(parent.context)
+        container.layoutParams = RecyclerView.LayoutParams(
+            RecyclerView.LayoutParams.WRAP_CONTENT,
+            RecyclerView.LayoutParams.WRAP_CONTENT
+        )
+        val itemType = itemTypeByViewType[viewType]
+            ?: throw IllegalStateException("Missing item type for viewType $viewType.")
+        val child = createView(itemType)
+        val existingParent = child.parent as? ViewGroup
+        existingParent?.removeView(child)
+
+        container.addView(child)
+        val holder = ViewHolder(container)
+        holder.hostedView = child
+        holder.itemType = itemType
+        holder.reactTag = child.id
+        return holder
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val item = requireDataSource().getItemAt(position)
+        val child = requireHostedView(holder, item)
+        prepareChildLayoutForMeasurement(child, item)
+        val reactTag = holder.reactTag
+        if (reactTag != null) {
+            val reactTagDouble = reactTag.toDouble()
+            val positionDouble = position.toDouble()
+            updateView(reactTagDouble, item, positionDouble)
+        }
+
+        captureMeasuredContentSize(item.key, child)
+        val contentSize = resolvedContentSize(item)
+        bindContainerLayout(holder.container, contentSize)
+        bindChildLayout(child, contentSize)
+    }
+
+    override fun getItemCount(): Int {
+        return dataSource?.getCountAsInt() ?: 0
+    }
+
+    fun retainMeasuredContent(dataSource: HybridNativeListDataSource) {
+        val activeKeys = mutableSetOf<String>()
+        val itemCount = dataSource.getCountAsInt()
+        for (index in 0 until itemCount) {
+            val item = dataSource.getItemAt(index)
+            activeKeys.add(item.key)
+        }
+
+        val measuredSizeIterator = measuredContentSizeByItemKey.keys.iterator()
+        while (measuredSizeIterator.hasNext()) {
+            val itemKey = measuredSizeIterator.next()
+            if (activeKeys.contains(itemKey)) {
+                continue
+            }
+            measuredSizeIterator.remove()
+        }
+    }
+
+    private fun requireDataSource(): HybridNativeListDataSource {
+        return dataSource ?: throw IllegalStateException("NativeListDataSource is not set.")
+    }
+
+    private fun requireHostedView(holder: ViewHolder, item: NativeListItem): View {
+        if (holder.itemType != item.type) {
+            throw IllegalStateException(
+                "RecyclerView supplied holder for type '${holder.itemType}' " +
+                    "to item type '${item.type}'."
+            )
+        }
+        return holder.hostedView ?: throw IllegalStateException("ViewHolder has no hosted view.")
+    }
+
+    private fun captureMeasuredContentSize(itemKey: String, view: View) {
+        val existingSize = measuredContentSizeByItemKey[itemKey]
+        val measuredWidth = positiveDimension(view.measuredWidth)
+        val measuredHeight = positiveDimension(view.measuredHeight)
+        val viewWidth = positiveDimension(view.width)
+        val viewHeight = positiveDimension(view.height)
+        val layoutWidth = positiveDimension(view.layoutParams?.width)
+        val layoutHeight = positiveDimension(view.layoutParams?.height)
+        val width = measuredWidth ?: viewWidth ?: layoutWidth
+        val height = measuredHeight ?: viewHeight ?: layoutHeight
+
+        val nextWidth = existingSize?.width ?: width
+        val nextHeight = existingSize?.height ?: height
+        if (nextWidth == null && nextHeight == null) {
+            return
+        }
+
+        measuredContentSizeByItemKey[itemKey] = PixelSize(
+            width = nextWidth,
+            height = nextHeight
+        )
+    }
+
+    private fun resolvedContentSize(item: NativeListItem): ResolvedPixelSize {
+        val measuredSize = measuredContentSizeByItemKey[item.key]
+        val width = item.width?.let { toPixels(it) } ?: measuredSize?.width
+        val height = item.height?.let { toPixels(it) } ?: measuredSize?.height
+
+        if (width == null) {
+            throw IllegalStateException(
+                "Missing width for item type '${item.type}'. " +
+                    "Provide width from getItemSize or render a measurable shell."
+            )
+        }
+        if (height == null) {
+            throw IllegalStateException(
+                "Missing height for item type '${item.type}'. " +
+                    "Provide height from getItemSize or render a measurable shell."
+            )
+        }
+
+        return ResolvedPixelSize(width, height)
+    }
+
+    private fun bindContainerLayout(container: FrameLayout, contentSize: ResolvedPixelSize) {
+        val horizontalInset = itemContentInsets.horizontal
+        val verticalInset = itemContentInsets.vertical
+        val containerWidth = contentSize.width + horizontalInset * 2
+        val containerHeight = contentSize.height + verticalInset * 2
+        val layoutParams = container.layoutParams as? RecyclerView.LayoutParams
+            ?: RecyclerView.LayoutParams(containerWidth, containerHeight)
+        layoutParams.width = containerWidth
+        layoutParams.height = containerHeight
+        container.layoutParams = layoutParams
+        container.setPadding(
+            horizontalInset,
+            verticalInset,
+            horizontalInset,
+            verticalInset
+        )
+    }
+
+    private fun bindChildLayout(child: View, contentSize: ResolvedPixelSize) {
+        val layoutParams = FrameLayout.LayoutParams(contentSize.width, contentSize.height)
+        child.layoutParams = layoutParams
+    }
+
+    private fun prepareChildLayoutForMeasurement(child: View, item: NativeListItem) {
+        if (item.width != null && item.height != null) {
+            return
+        }
+
+        val width = item.width?.let { toPixels(it) } ?: ViewGroup.LayoutParams.WRAP_CONTENT
+        val height = item.height?.let { toPixels(it) } ?: ViewGroup.LayoutParams.WRAP_CONTENT
+        val layoutParams = FrameLayout.LayoutParams(width, height)
+        child.layoutParams = layoutParams
+    }
+
+    private fun positiveDimension(value: Int?): Int? {
+        if (value == null || value <= 0) {
+            return null
+        }
+        return value
+    }
+
+    private fun toPixels(value: Double): Int {
+        val density = reactContext.resources.displayMetrics.density
+        val pixels = value * density
+        val rounded = pixels.roundToInt()
+        return rounded.coerceAtLeast(1)
+    }
+}