react-native-list 1.0.1 → 2.0.0-alpha.2

package/android/src/main/cpp/JHybridUiListModule.cpp

@@ -0,0 +1,192 @@
+#include "JHybridUiListModule.h"
+#include "WorkletsUiCallInvoker.hpp"
+#include "HybridUiManagerHelper.hpp"
+
+#include <NitroModules/CallInvokerDispatcher.hpp>
+#include <NitroModules/InstallNitro.hpp>
+#include <react/utils/jsi-utils.h>
+#include <react/fabric/FabricUIManagerBinding.h>
+#include <worklets/android/WorkletsModule.h>
+
+namespace margelo::nitro::reactnativelist
+{
+    static bool isOnAndroidUiThread()
+    {
+        return getpid() == gettid();
+    }
+
+    std::shared_ptr<react::CallInvoker> JHybridUiListModule::uiCallInvoker_ = nullptr;
+    std::shared_ptr<worklets::WorkletRuntime> JHybridUiListModule::uiWorkletRuntime_ = nullptr;
+
+    void JHybridUiListModule::registerNatives()
+    {
+        javaClassStatic()->registerNatives({
+            makeNativeMethod("prepareUiRuntime",
+                             prepareUiRuntime),
+            makeNativeMethod("getUiCallInvokerHolder",
+                             getUiCallInvokerHolder),
+            makeNativeMethod("getUiRuntimeExecutor",
+                             getUiRuntimeExecutor),
+            makeNativeMethod("setupEventInterceptor",
+                             setupEventInterceptor),
+        });
+    }
+
+    std::shared_ptr<react::CallInvoker> JHybridUiListModule::getOrInitCallInvoker(
+        jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule)
+    {
+        if (!workletsModule)
+        {
+            throw std::runtime_error("WorkletsModule reference is null");
+        }
+
+        auto workletsModuleProxy =
+            workletsModule->cthis()->getWorkletsModuleProxy();
+
+        if (!workletsModuleProxy)
+        {
+            throw std::runtime_error("Failed to get WorkletsModuleProxy from WorkletsModule");
+        }
+
+        auto uiScheduler = workletsModuleProxy->getUIScheduler();
+        if (!uiScheduler)
+        {
+            throw std::runtime_error("Failed to get UIScheduler from WorkletsModuleProxy");
+        }
+
+        auto uiWorkletRuntime = workletsModuleProxy->getUIWorkletRuntime();
+        if (!uiWorkletRuntime)
+        {
+            throw std::runtime_error("Failed to get UIWorkletRuntime from WorkletsModuleProxy");
+        }
+
+        if (uiCallInvoker_ && uiWorkletRuntime_ == uiWorkletRuntime)
+        {
+            return uiCallInvoker_;
+        }
+
+        uiWorkletRuntime_ = uiWorkletRuntime;
+        uiCallInvoker_ = std::make_shared<WorkletsUiCallInvoker>(uiScheduler, uiWorkletRuntime, isOnAndroidUiThread);
+        return uiCallInvoker_;
+    }
+
+    jni::local_ref<react::CallInvokerHolder::javaobject>
+    JHybridUiListModule::getUiCallInvokerHolder(
+        jni::alias_ref<JHybridUiListModule> jThis,
+        jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule)
+    {
+        std::shared_ptr<react::CallInvoker> uiCallInvoker = getOrInitCallInvoker(workletsModule);
+
+        return react::CallInvokerHolder::newObjectCxxArgs(uiCallInvoker);
+    }
+
+    bool JHybridUiListModule::prepareUiRuntime(
+        jni::alias_ref<JHybridUiListModule> jThis,
+        jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule)
+    {
+        if (!workletsModule)
+        {
+            throw std::runtime_error("WorkletsModule reference is null");
+        }
+
+        auto workletsModuleProxy =
+            workletsModule->cthis()->getWorkletsModuleProxy();
+
+        if (!workletsModuleProxy)
+        {
+            throw std::runtime_error("Failed to get WorkletsModuleProxy from WorkletsModule");
+        }
+
+        auto uiWorkletRuntime = workletsModuleProxy->getUIWorkletRuntime();
+        if (!uiWorkletRuntime)
+        {
+            throw std::runtime_error("Failed to get UIWorkletRuntime from WorkletsModuleProxy");
+        }
+
+        std::shared_ptr<react::CallInvoker> uiCallInvoker = getOrInitCallInvoker(workletsModule);
+
+        // React Native checks this global while installing TurboModule bindings.
+        // Worklets creates a separate UI runtime, so we mirror the bridgeless marker there.
+        bool hasNativeModuleProxy = false;
+        uiWorkletRuntime->runSync([&hasNativeModuleProxy](jsi::Runtime &runtime)
+                                  {
+                                      auto global = runtime.global();
+                                      if (!global.hasProperty(runtime, "RN$Bridgeless"))
+                                      {
+                                          react::defineReadOnlyGlobal(runtime, "RN$Bridgeless", jsi::Value(true));
+                                      }
+
+                                      hasNativeModuleProxy = global.hasProperty(runtime, "nativeModuleProxy");
+                                  });
+
+        // Do not call the Android Nitro TurboModule installer from the UI runtime.
+        // That installer reads ReactApplicationContext.javaScriptContextHolder, which always
+        // points at the main RN JS runtime. Install Nitro directly into Worklets' UI runtime
+        // so UI-thread imports can reuse global.NitroModulesProxy instead of reinstalling on RN.
+        uiWorkletRuntime->runSync([uiCallInvoker](jsi::Runtime &runtime)
+                                  {
+                                      if (runtime.global().hasProperty(runtime, "NitroModulesProxy"))
+                                      {
+                                          return;
+                                      }
+
+                                      if (runtime.global().hasProperty(runtime, "__nitroDispatcher"))
+                                      {
+                                          margelo::nitro::install(runtime);
+                                          return;
+                                      }
+
+                                      auto dispatcher =
+                                          std::make_shared<margelo::nitro::CallInvokerDispatcher>(uiCallInvoker);
+                                      margelo::nitro::install(runtime, dispatcher);
+                                  });
+
+        return hasNativeModuleProxy;
+    }
+
+    jni::local_ref<react::JRuntimeExecutor::javaobject>
+    JHybridUiListModule::getUiRuntimeExecutor(
+        jni::alias_ref<JHybridUiListModule> jThis,
+        jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule)
+    {
+        std::shared_ptr<react::CallInvoker> uiCallInvoker = getOrInitCallInvoker(workletsModule);
+
+        RuntimeExecutor uiRuntimeExecutor = [uiCallInvoker](auto callback)
+        {
+            if (isOnAndroidUiThread())
+            {
+                uiCallInvoker->invokeSync(std::move(callback));
+                return;
+            }
+
+            uiCallInvoker->invokeAsync(std::move(callback));
+        };
+
+        return react::JRuntimeExecutor::newObjectCxxArgs(uiRuntimeExecutor);
+    }
+
+    void JHybridUiListModule::setupEventInterceptor(
+        jni::alias_ref<JHybridUiListModule> jThis,
+        jni::alias_ref<JFabricUIManager::javaobject> fabricUIManager)
+    {
+        if (!uiCallInvoker_)
+        {
+            throw std::runtime_error(
+                "UI CallInvoker must be initialized before setting up event interceptor");
+        }
+
+        if (!fabricUIManager)
+        {
+            throw std::runtime_error("FabricUIManager reference is null");
+        }
+        std::shared_ptr<react::Scheduler> scheduler = fabricUIManager->getBinding()->getScheduler();
+
+        if (!scheduler)
+        {
+            throw std::runtime_error("Failed to get Scheduler from FabricUIManager");
+        }
+
+        HybridUiManagerHelper::setupEventInterceptor(scheduler, uiCallInvoker_);
+    }
+
+} // namespace margelo::nitro::reactnativelist

package/android/src/main/cpp/JHybridUiListModule.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <ReactCommon/CallInvokerHolder.h>
+#include <react/jni/JRuntimeExecutor.h>
+#include <fbjni/fbjni.h>
+#include <react/fabric/JFabricUIManager.h>
+#include <react/renderer/core/EventListener.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/android/WorkletsModule.h>
+
+namespace margelo::nitro::reactnativelist
+{
+
+    using namespace facebook;
+
+    struct JHybridUiListModule : public jni::JavaClass<JHybridUiListModule>
+    {
+        static auto constexpr kJavaDescriptor =
+            "Lcom/margelo/nitro/reactnativelist/HybridUiListModule;";
+
+        static void registerNatives();
+
+    private:
+        static jni::local_ref<react::CallInvokerHolder::javaobject>
+        getUiCallInvokerHolder(
+            jni::alias_ref<JHybridUiListModule> jThis,
+            jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule);
+
+        static jni::local_ref<react::JRuntimeExecutor::javaobject>
+        getUiRuntimeExecutor(
+            jni::alias_ref<JHybridUiListModule> jThis,
+            jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule);
+
+        static bool prepareUiRuntime(
+            jni::alias_ref<JHybridUiListModule> jThis,
+            jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule);
+
+        static void setupEventInterceptor(
+            jni::alias_ref<JHybridUiListModule> jThis,
+            jni::alias_ref<JFabricUIManager::javaobject> fabricUIManager);
+
+        static std::shared_ptr<react::CallInvoker> getOrInitCallInvoker(jni::alias_ref<worklets::WorkletsModule::javaobject> workletsModule);
+
+    private:
+        static std::shared_ptr<react::CallInvoker> uiCallInvoker_;
+        static std::shared_ptr<worklets::WorkletRuntime> uiWorkletRuntime_;
+        static std::shared_ptr<const react::EventListener> eventInterceptor_;
+    };
+
+} // namespace margelo::nitro::reactnativelist

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,12 @@
+#include <jni.h>
+#include "ReactNativeListOnLoad.hpp"
+#include "JHybridUiListModule.h"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *)
+{
+  return facebook::jni::initialize(vm, []() {
+      margelo::nitro::reactnativelist::registerAllNatives();
+      // Register additional native methods (not generated by Nitrogen)
+      margelo::nitro::reactnativelist::JHybridUiListModule::registerNatives();
+  });
+}

package/android/src/main/java/com/hannojg/reactnativelist/ReactNativeListPackage.kt

@@ -0,0 +1,27 @@
+package com.hannojg.reactnativelist
+
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.reactnativelist.ReactNativeListOnLoad
+import com.margelo.nitro.reactnativelist.views.HybridUiListViewManager
+
+class ReactNativeListPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<in Nothing, in Nothing>> {
+        val viewManagers = ArrayList<ViewManager<*, *>>()
+        viewManagers.add(HybridUiListViewManager())
+        return viewManagers
+    }
+
+    companion object {
+        init {
+            ReactNativeListOnLoad.initializeNative()
+        }
+    }
+}

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

@@ -0,0 +1,146 @@
+package com.margelo.nitro.reactnativelist
+
+import androidx.recyclerview.widget.DiffUtil
+
+internal interface NativeListDataSourceObserver {
+    fun dataSourceDidReload(diffResult: DiffUtil.DiffResult?, animated: Boolean)
+    fun dataSourceDidInsert(index: Int)
+    fun dataSourceDidUpdate(index: Int, previousItem: NativeListItem)
+    fun dataSourceDidRemove(index: Int, removedItem: NativeListItem)
+    fun dataSourceDidMove(fromIndex: Int, toIndex: Int)
+}
+
+class HybridNativeListDataSource : HybridNativeListDataSourceSpec() {
+    internal var observer: NativeListDataSourceObserver? = null
+    private var items: List<NativeListItem> = emptyList()
+    private var isContentEqual: (oldItem: NativeListItem, newItem: NativeListItem) -> Boolean =
+        { _, _ -> false }
+
+    override fun dispose() {
+        observer = null
+        items = emptyList()
+        isContentEqual = { _, _ -> false }
+    }
+
+    override fun setContentEqualCallback(
+        isContentEqual: (oldItem: NativeListItem, newItem: NativeListItem) -> Boolean
+    ) {
+        this.isContentEqual = isContentEqual
+    }
+
+    override fun replaceData(items: Array<NativeListItem>, animated: Boolean) {
+        val nextItems = items.toList()
+        if (!animated) {
+            this.items = nextItems
+            observer?.dataSourceDidReload(null, false)
+            return
+        }
+
+        val previousItems = this.items
+        val callback = NativeDiffCallback(previousItems, nextItems, isContentEqual)
+        val diffResult = DiffUtil.calculateDiff(callback, true)
+        this.items = nextItems
+        observer?.dataSourceDidReload(diffResult, true)
+    }
+
+    override fun insertItem(index: Double, item: NativeListItem) {
+        val itemIndex = validateInsertionIndex(index.toInt())
+        val mutableItems = items.toMutableList()
+        mutableItems.add(itemIndex, item)
+        items = mutableItems
+        observer?.dataSourceDidInsert(itemIndex)
+    }
+
+    override fun updateItem(index: Double, item: NativeListItem) {
+        val itemIndex = validateExistingIndex(index.toInt())
+        val mutableItems = items.toMutableList()
+        val previousItem = mutableItems[itemIndex]
+        mutableItems[itemIndex] = item
+        items = mutableItems
+        observer?.dataSourceDidUpdate(itemIndex, previousItem)
+    }
+
+    override fun removeItem(index: Double) {
+        val itemIndex = validateExistingIndex(index.toInt())
+        val mutableItems = items.toMutableList()
+        val removedItem = mutableItems.removeAt(itemIndex)
+        items = mutableItems
+        observer?.dataSourceDidRemove(itemIndex, removedItem)
+    }
+
+    override fun moveItem(fromIndex: Double, toIndex: Double) {
+        val sourceIndex = validateExistingIndex(fromIndex.toInt())
+        val targetIndex = validateExistingIndex(toIndex.toInt())
+        val mutableItems = items.toMutableList()
+        val item = mutableItems.removeAt(sourceIndex)
+        mutableItems.add(targetIndex, item)
+        items = mutableItems
+        observer?.dataSourceDidMove(sourceIndex, targetIndex)
+    }
+
+    override fun getCount(): Double {
+        return items.size.toDouble()
+    }
+
+    override fun getItem(index: Double): NativeListItem {
+        val itemIndex = validateExistingIndex(index.toInt())
+        return getItemAt(itemIndex)
+    }
+
+    internal fun getItemAt(index: Int): NativeListItem {
+        return items[index]
+    }
+
+    internal fun getCountAsInt(): Int {
+        return items.size
+    }
+
+    private fun validateExistingIndex(index: Int): Int {
+        if (index < 0 || index >= items.size) {
+            throw IndexOutOfBoundsException("List index $index is out of bounds.")
+        }
+        return index
+    }
+
+    private fun validateInsertionIndex(index: Int): Int {
+        if (index < 0 || index > items.size) {
+            throw IndexOutOfBoundsException("List index $index is out of bounds.")
+        }
+        return index
+    }
+}
+
+private class NativeDiffCallback(
+    private val oldItems: List<NativeListItem>,
+    private val newItems: List<NativeListItem>,
+    private val isContentEqual: (oldItem: NativeListItem, newItem: NativeListItem) -> Boolean
+) : DiffUtil.Callback() {
+
+    override fun getOldListSize(): Int {
+        return oldItems.size
+    }
+
+    override fun getNewListSize(): Int {
+        return newItems.size
+    }
+
+    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
+        val oldItem = oldItems[oldItemPosition]
+        val newItem = newItems[newItemPosition]
+        return oldItem.key == newItem.key && oldItem.type == newItem.type
+    }
+
+    override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
+        val oldItem = oldItems[oldItemPosition]
+        val newItem = newItems[newItemPosition]
+
+        if (oldItem.width != newItem.width) {
+            return false
+        }
+        if (oldItem.height != newItem.height) {
+            return false
+        }
+
+        return isContentEqual(oldItem, newItem)
+    }
+}

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

@@ -0,0 +1,86 @@
+package com.margelo.nitro.reactnativelist
+
+import android.graphics.Rect
+import android.view.View
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.facebook.react.uimanager.ThemedReactContext
+import kotlin.math.roundToInt
+
+open class HybridNativeListLayout : HybridNativeListLayoutSpec()
+
+internal interface NativeListLayoutProvider {
+    fun applyTo(recyclerView: RecyclerView, reactContext: ThemedReactContext)
+    fun itemContentInsets(reactContext: ThemedReactContext): ItemContentInsets
+}
+
+data class ItemContentInsets(
+    val horizontal: Int,
+    val vertical: Int
+)
+
+class HybridNativeLinearListLayout :
+    HybridNativeLinearListLayoutSpec(),
+    NativeListLayoutProvider {
+    private var topInset = 16
+    private var bottomInset = 16
+    private var itemSpacing = 12
+    private var itemHorizontalInset = 0
+    private var itemVerticalInset = 0
+
+    override fun dispose() {
+        topInset = 16
+        bottomInset = 16
+        itemSpacing = 12
+        itemHorizontalInset = 0
+        itemVerticalInset = 0
+    }
+
+    override fun setConfig(config: NativeLinearListLayoutConfig) {
+        topInset = config.topInset.roundToInt()
+        bottomInset = config.bottomInset.roundToInt()
+        itemSpacing = config.itemSpacing.roundToInt()
+        itemHorizontalInset = config.itemHorizontalInset.roundToInt()
+        itemVerticalInset = config.itemVerticalInset.roundToInt()
+    }
+
+    override fun applyTo(recyclerView: RecyclerView, reactContext: ThemedReactContext) {
+        recyclerView.layoutManager = LinearLayoutManager(reactContext)
+        recyclerView.clipToPadding = false
+        val density = reactContext.resources.displayMetrics.density
+        val topPadding = (topInset * density).roundToInt()
+        val bottomPadding = (bottomInset * density).roundToInt()
+        val spacing = (itemSpacing * density).roundToInt()
+
+        while (recyclerView.itemDecorationCount > 0) {
+            recyclerView.removeItemDecorationAt(0)
+        }
+
+        recyclerView.setPadding(0, topPadding, 0, bottomPadding)
+        recyclerView.addItemDecoration(LinearSpacingDecoration(spacing))
+    }
+
+    override fun itemContentInsets(reactContext: ThemedReactContext): ItemContentInsets {
+        val density = reactContext.resources.displayMetrics.density
+        val horizontal = (itemHorizontalInset * density).roundToInt()
+        val vertical = (itemVerticalInset * density).roundToInt()
+        return ItemContentInsets(horizontal, vertical)
+    }
+}
+
+private class LinearSpacingDecoration(
+    private val itemSpacing: Int
+) : RecyclerView.ItemDecoration() {
+    override fun getItemOffsets(
+        outRect: Rect,
+        view: View,
+        parent: RecyclerView,
+        state: RecyclerView.State
+    ) {
+        val position = parent.getChildAdapterPosition(view)
+        val itemCount = state.itemCount
+        if (position >= 0 && position < itemCount - 1) {
+            outRect.bottom = itemSpacing
+        }
+    }
+}

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

@@ -0,0 +1,116 @@
+package com.margelo.nitro.reactnativelist
+
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.RuntimeExecutor
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.fabric.FabricUIManager
+import com.facebook.react.internal.turbomodule.core.TurboModuleManager
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
+import com.facebook.react.runtime.ReactHostDelegate
+import com.facebook.react.runtime.ReactHostImpl
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHolder
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.margelo.nitro.NitroModules
+import com.swmansion.worklets.WorkletsModule
+import java.util.ArrayList
+import kotlin.concurrent.Volatile
+
+class HybridUiListModule : HybridUiListModuleSpec() {
+    override fun iosGetWorkletsModule(): HybridIOSWorkletsModuleProxyHolderSpec {
+        throw IllegalStateException("iosGetWorkletsModule is iOS-only and must not be called on Android.")
+    }
+
+    @OptIn(UnstableReactNativeAPI::class, FrameworkAPI::class)
+    override fun setupRuntime(workletsModuleHolder: Variant_NullType_HybridIOSWorkletsModuleProxyHolderSpec?) {
+        if (!UiThreadUtil.isOnUiThread()) {
+            throw IllegalStateException("setupRuntime must be called on the UI thread!")
+        }
+
+        val context: ReactApplicationContext = NitroModules.applicationContext
+            ?: throw IllegalStateException("ReactApplicationContext is null! Is Nitro installed?")
+
+        val workletsModule = context.getNativeModule(WorkletsModule::class.java)
+            ?: throw IllegalStateException("WorkletsModule is null! Is the WorkletsModule properly registered?")
+        val nativeModuleProxyInstalled = prepareUiRuntime(workletsModule)
+
+        if (!nativeModuleProxyInstalled) {
+            val reactActivity = context.currentActivity as? ReactActivity
+                ?: throw IllegalStateException("Current activity is not a ReactActivity!")
+            val reactHost = reactActivity.reactActivityDelegate.reactHost
+                ?: throw IllegalStateException("ReactNativeHost is null!")
+
+            // Next: Create a TurboModuleManager for the UI runtime, which will set global.nativeModuleProxy
+            // This is whats being used when doing NativeModule.MyNativeModule in JS!
+            // TODO: i use a bunch of internals here, can this be improved?
+            val reactHostImpl = reactHost as? ReactHostImpl
+                ?: throw IllegalStateException("ReactHost is not a ReactHostImpl! Is the New Architecture enabled?")
+
+            val reactHostDelegateField = reactHostImpl.javaClass.getDeclaredField("reactHostDelegate")
+            reactHostDelegateField.isAccessible = true
+            val reactHostDelegate = reactHostDelegateField.get(reactHostImpl) as? ReactHostDelegate
+                ?: throw IllegalStateException("ReactHostDelegate is null! Is the New Architecture enabled?")
+
+            // Get nativeMethodCallInvokerHolder from reactInstance, which lives on reactHostImpl
+            val reactInstanceField = reactHostImpl.javaClass.getDeclaredField("reactInstance")
+            reactInstanceField.isAccessible = true
+            val reactInstance = reactInstanceField.get(reactHostImpl)
+                ?: throw IllegalStateException("ReactInstance is null! Is the New Architecture enabled?")
+            val getNativeMethodCallInvokerHolderMethod = reactInstance.javaClass.getDeclaredMethod("getNativeMethodCallInvokerHolder")
+            getNativeMethodCallInvokerHolderMethod.isAccessible = true
+            val nativeMethodCallInvokerHolder = getNativeMethodCallInvokerHolderMethod.invoke(reactInstance) as? NativeMethodCallInvokerHolder
+                ?: throw IllegalStateException("NativeMethodCallInvokerHolder is null! Is the New Architecture enabled?")
+
+            val reactPackages: MutableList<ReactPackage> = ArrayList<ReactPackage>()
+            val coreReactPackageClass = Class.forName("com.facebook.react.runtime.CoreReactPackage")
+            val constructor = coreReactPackageClass.declaredConstructors.first()
+            constructor.isAccessible = true
+            // TODO: this will create dev support modules on the UI runtime which is unnecessary overhead we don't need!
+            //       In a past version i simply put in the most important core modules from JS, which was somewhat nicer.
+            val coreReactPackage = constructor.newInstance(reactHost.devSupportManager, DefaultHardwareBackBtnHandler {}) as ReactPackage
+            reactPackages.add(coreReactPackage)
+            reactPackages.addAll(reactHostDelegate.reactPackages)
+
+            val turboModuleManagerDelegate = reactHostDelegate.turboModuleManagerDelegateBuilder
+                .setPackages(reactPackages)
+                .setReactApplicationContext(context)
+                .build()
+
+            val uiCallInvokerHolder = getUiCallInvokerHolder(workletsModule)
+            val uiRuntimeExecutor = getUiRuntimeExecutor(workletsModule)
+
+            // This will install the JSI bindings
+            uiTurboModuleManager = TurboModuleManager(
+                // TurboModuleManager will call jni -> cpp, to actually setup nativeModuleProxy
+                runtimeExecutor = uiRuntimeExecutor,
+                delegate = turboModuleManagerDelegate,
+                jsCallInvokerHolder = uiCallInvokerHolder,
+                nativeMethodCallInvokerHolder = nativeMethodCallInvokerHolder
+            )
+        }
+
+        val uiManager = UIManagerHelper.getUIManager(context, UIManagerType.FABRIC)
+            ?: throw IllegalStateException("Fabric UIManager is null! Is the Fabric architecture enabled?")
+        val fabricUIManager = uiManager as? FabricUIManager
+            ?: throw IllegalStateException("UIManager is not a FabricUIManager! Is the Fabric architecture enabled?")
+        setupEventInterceptor(fabricUIManager)
+    }
+
+    @OptIn(FrameworkAPI::class)
+    private external fun prepareUiRuntime(workletsModule: WorkletsModule): Boolean
+
+    @OptIn(FrameworkAPI::class)
+    private external fun getUiCallInvokerHolder(workletsModule: WorkletsModule): CallInvokerHolderImpl
+
+    private external fun getUiRuntimeExecutor(workletsModule: WorkletsModule): RuntimeExecutor
+
+    private external fun setupEventInterceptor(fabricUIManager: FabricUIManager)
+
+    @Volatile
+    private lateinit var uiTurboModuleManager: TurboModuleManager
+}