@amazon-devices/react-native-screens 2.0.1759135970 → 3.0.9000000000

package/android/CMakeLists.txt

@@ -0,0 +1,80 @@
+cmake_minimum_required(VERSION 3.9.0)
+
+project(rnscreens)
+
+if(${RNS_NEW_ARCH_ENABLED})
+add_library(rnscreens
+    SHARED
+    ../cpp/RNScreensTurboModule.cpp
+    ../cpp/RNSScreenRemovalListener.cpp
+    ./src/main/cpp/jni-adapter.cpp
+    ./src/main/cpp/NativeProxy.cpp
+    ./src/main/cpp/OnLoad.cpp
+)
+else()
+add_library(rnscreens
+    SHARED
+    ../cpp/RNScreensTurboModule.cpp
+    ./src/main/cpp/jni-adapter.cpp
+)
+endif()
+
+include_directories(
+    ../cpp
+)
+
+set_target_properties(rnscreens PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON
+    CXX_EXTENSIONS OFF
+    POSITION_INDEPENDENT_CODE ON
+)
+
+target_compile_definitions(
+    rnscreens
+    PRIVATE
+    -DFOLLY_NO_CONFIG=1
+)
+
+find_package(ReactAndroid REQUIRED CONFIG)
+
+if(${RNS_NEW_ARCH_ENABLED})
+    find_package(fbjni REQUIRED CONFIG)
+    
+    if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+        target_link_libraries(rnscreens
+            ReactAndroid::reactnative
+            ReactAndroid::jsi
+            fbjni::fbjni
+            android
+        )
+    else()
+        target_link_libraries(
+            rnscreens
+                ReactAndroid::jsi
+                ReactAndroid::react_nativemodule_core
+                ReactAndroid::react_utils
+                ReactAndroid::reactnativejni
+                ReactAndroid::fabricjni
+                ReactAndroid::react_debug
+                ReactAndroid::react_render_core
+                ReactAndroid::runtimeexecutor
+                ReactAndroid::react_render_graphics
+                ReactAndroid::rrc_view
+                ReactAndroid::yoga
+                ReactAndroid::rrc_text
+                ReactAndroid::glog
+                ReactAndroid::react_render_componentregistry
+                ReactAndroid::react_render_consistency
+                ReactAndroid::react_performance_timeline
+                ReactAndroid::react_render_observers_events
+                fbjni::fbjni
+                android
+        )
+    endif()
+else()
+    target_link_libraries(rnscreens
+        ReactAndroid::jsi
+        android
+    )
+endif()

package/android/build.gradle

@@ -1,4 +1,5 @@
 import com.android.Version
+import groovy.json.JsonSlurper
 
 buildscript {
     ext {
@@ -8,7 +9,11 @@ buildscript {
         rnsDefaultKotlinVersion = '1.8.0'
     }
     ext.safeExtGet = {prop, fallback ->
-        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+        def props = (prop instanceof String) ? [prop] : prop
+        def result = props.find { key ->
+            return rootProject.ext.has(key)
+        }
+        return result ? rootProject.ext.get(result) : fallback
     }
     repositories {
         google()
@@ -17,10 +22,14 @@ buildscript {
     dependencies {
         classpath('com.android.tools.build:gradle:4.2.2')
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', rnsDefaultKotlinVersion)}"
-        classpath "com.diffplug.spotless:spotless-plugin-gradle:6.11.0"
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:6.25.0"
     }
 }
 
+def isRunningInContextOfScreensRepo() {
+    return project == rootProject
+}
+
 def isNewArchitectureEnabled() {
     // To opt-in for the New Architecture, you can either:
     // - Set `newArchEnabled` to true inside the `gradle.properties` file
@@ -29,8 +38,44 @@ def isNewArchitectureEnabled() {
     return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
 }
 
+def resolveReactNativeDirectory() {
+    def userDefinedRnDirPath = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+    if (userDefinedRnDirPath != null) {
+        return file(userDefinedRnDirPath)
+    }
+
+    File standardRnDirFile = file("$rootDir/../node_modules/react-native/")
+    if (standardRnDirFile.exists()) {
+        return standardRnDirFile
+    }
+
+    // This is legacy code, I'm not sure why it works in certain scenarios but it was reported that one of our
+    // projects needs this.
+    File legacyRnDirFile = file("$projectDir/../node_modules/react-native/")
+    if (legacyRnDirFile.exists()) {
+        return legacyRnDirFile
+    }
+
+    // We're in non standard setup, e.g. monorepo - try to use node resolver to locate the react-native package.
+    String maybeRnPackagePath = ["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim()
+
+    File nodeResolverRnDirFile = null
+    // file() constructor fails in case string is null or blank
+    if (maybeRnPackagePath != null && !maybeRnPackagePath.isBlank()) {
+        File maybeRnPackageFile = file(maybeRnPackagePath)
+        if (maybeRnPackageFile.exists()) {
+            nodeResolverRnDirFile = maybeRnPackageFile.parentFile
+            return nodeResolverRnDirFile
+        }
+    }
+
+    throw new Exception("[RNScreens] Failed to resolve react-native directory. " +
+            "Attempted locations: ${standardRnDirFile}, ${legacyRnDirFile} and ${nodeResolverRnDirFile}. " +
+            "You should set project extension property (in `app/build.gradle`) `REACT_NATIVE_NODE_MODULES_DIR` with path to react-native.")
+}
+
 // spotless is only accessible within react-native-screens repo
-if (project == rootProject) {
+if (isRunningInContextOfScreensRepo()) {
     apply from: 'spotless.gradle'
 }
 
@@ -45,11 +90,21 @@ def reactNativeArchitectures() {
     return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
+def safeAppExtGet(prop, fallback) {
+    def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+    appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
+}
+
+def IS_NEW_ARCHITECTURE_ENABLED = isNewArchitectureEnabled()
+
 android {
     compileSdkVersion safeExtGet('compileSdkVersion', rnsDefaultCompileSdkVersion)
     def agpVersion = Version.ANDROID_GRADLE_PLUGIN_VERSION
     if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
         namespace "com.swmansion.rnscreens"
+        buildFeatures {
+            buildConfig true
+        }
     }
 
     // Used to override the NDK path/version on internal CI or by allowing
@@ -62,14 +117,28 @@ android {
     }
 
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', rnsDefaultMinSdkVersion)
-        targetSdkVersion safeExtGet('targetSdkVersion', rnsDefaultTargetSdkVersion)
+        minSdkVersion safeExtGet(['minSdkVersion', 'minSdk'], rnsDefaultMinSdkVersion)
+        targetSdkVersion safeExtGet(['targetSdkVersion', 'targetSdk'], rnsDefaultTargetSdkVersion)
         versionCode 1
         versionName "1.0"
-        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", IS_NEW_ARCHITECTURE_ENABLED.toString()
         ndk {
             abiFilters (*reactNativeArchitectures())
         }
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared",
+                        "-DRNS_NEW_ARCH_ENABLED=${IS_NEW_ARCHITECTURE_ENABLED}"
+            }
+        }
+    }
+    buildFeatures {
+        prefab true
+    }
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
     }
     lintOptions {
         abortOnError false
@@ -83,25 +152,31 @@ android {
         // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
         // only the ones that make the build fail (ideally we should only include librnscreens_modules but we
         // are only allowed to specify exclude patterns)
-        exclude "**/libreact_render*.so"
+        excludes = [
+                "META-INF",
+                "META-INF/**",
+                "**/libjsi.so",
+                "**/libc++_shared.so",
+                "**/libreact_render*.so",
+                "**/libreactnativejni.so",
+                "**/libreact_performance_timeline.so"
+        ]
     }
     sourceSets.main {
         ext.androidResDir = "src/main/res"
         java {
-            if (isNewArchitectureEnabled()) {
+            if (IS_NEW_ARCHITECTURE_ENABLED) {
                 srcDirs += [
                     "src/fabric/java",
                 ]
             } else {
                 srcDirs += [
                     "src/paper/java",
-                    "build/generated/source/codegen/java"
                 ]
             }
-
         }
         res {
-            if (safeExtGet('compileSdkVersion', rnsDefaultCompileSdkVersion) >= 33) {
+            if (safeExtGet(['compileSdkVersion', 'compileSdk'], rnsDefaultCompileSdkVersion) >= 33) {
                 srcDirs = ["${androidResDir}/base", "${androidResDir}/v33"]
             } else {
                 srcDirs = ["${androidResDir}/base"]
@@ -112,11 +187,9 @@ android {
 
 repositories {
     maven {
-        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-        // Matches the RN Hello World template
-        // https://github.com/facebook/react-native/blob/1e8f3b11027fe0a7514b4fc97d0798d3c64bc895/local-cli/templates/HelloWorld/android/build.gradle#L21
-        url "$projectDir/../node_modules/react-native/android"
+        url "${resolveReactNativeDirectory()}/android"
     }
+
     mavenCentral()
     mavenLocal()
     google()
@@ -128,6 +201,12 @@ dependencies {
     implementation 'androidx.fragment:fragment-ktx:1.6.1'
     implementation 'androidx.coordinatorlayout:coordinatorlayout:1.2.0'
     implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
-    implementation 'com.google.android.material:material:1.9.0'
-    implementation "androidx.core:core-ktx:1.10.1"
+    implementation 'com.google.android.material:material:1.6.1'
+    implementation "androidx.core:core-ktx:1.8.0"
+
+    constraints {
+        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1") {
+            because("on older React Native versions this dependency conflicts with react-native-screens")
+        }
+    }
 }

package/android/src/fabric/java/com/swmansion/rnscreens/FabricEnabledHeaderConfigViewGroup.kt

@@ -0,0 +1,61 @@
+package com.swmansion.rnscreens
+
+import android.content.Context
+import android.view.ViewGroup
+import androidx.annotation.UiThread
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.StateWrapper
+import kotlin.math.abs
+
+abstract class FabricEnabledHeaderConfigViewGroup(
+    context: Context?,
+) : ViewGroup(context) {
+    private var mStateWrapper: StateWrapper? = null
+
+    private var lastPaddingStart = 0f
+    private var lastPaddingEnd = 0f
+
+    fun setStateWrapper(wrapper: StateWrapper?) {
+        mStateWrapper = wrapper
+    }
+
+    fun updatePaddingsFabric(
+        paddingStart: Int,
+        paddingEnd: Int,
+    ) {
+        updateState(paddingStart, paddingEnd)
+    }
+
+    @UiThread
+    fun updateState(
+        paddingStart: Int,
+        paddingEnd: Int,
+    ) {
+        val paddingStartDip: Float = PixelUtil.toDIPFromPixel(paddingStart.toFloat())
+        val paddingEndDip: Float = PixelUtil.toDIPFromPixel(paddingEnd.toFloat())
+
+        // Check incoming state values. If they're already the correct value, return early to prevent
+        // infinite UpdateState/SetState loop.
+        if (abs(lastPaddingStart - paddingStart) < DELTA &&
+            abs(lastPaddingEnd - paddingEnd) < DELTA
+        ) {
+            return
+        }
+
+        lastPaddingStart = paddingStartDip
+        lastPaddingEnd = paddingEndDip
+
+        val map: WritableMap =
+            WritableNativeMap().apply {
+                putDouble("paddingStart", paddingStartDip.toDouble())
+                putDouble("paddingEnd", paddingEndDip.toDouble())
+            }
+        mStateWrapper?.updateState(map)
+    }
+
+    companion object {
+        private const val DELTA = 0.9f
+    }
+}

package/android/src/fabric/java/com/swmansion/rnscreens/FabricEnabledViewGroup.kt

@@ -3,47 +3,60 @@ package com.swmansion.rnscreens
 import android.view.ViewGroup
 import androidx.annotation.UiThread
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
-import com.facebook.react.uimanager.FabricViewStateManager
 import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.StateWrapper
 import kotlin.math.abs
 
-abstract class FabricEnabledViewGroup constructor(context: ReactContext?) : ViewGroup(context), FabricViewStateManager.HasFabricViewStateManager {
-    private val mFabricViewStateManager: FabricViewStateManager = FabricViewStateManager()
+abstract class FabricEnabledViewGroup(
+    context: ReactContext?,
+) : ViewGroup(context) {
+    private var mStateWrapper: StateWrapper? = null
 
-    override fun getFabricViewStateManager(): FabricViewStateManager {
-        return mFabricViewStateManager
+    private var lastSetWidth = 0f
+    private var lastSetHeight = 0f
+
+    fun setStateWrapper(wrapper: StateWrapper?) {
+        mStateWrapper = wrapper
     }
 
-    protected fun updateScreenSizeFabric(width: Int, height: Int) {
-        updateState(width, height)
+    protected fun updateScreenSizeFabric(
+        width: Int,
+        height: Int,
+        headerHeight: Int,
+    ) {
+        updateState(width, height, headerHeight)
     }
 
     @UiThread
-    fun updateState(width: Int, height: Int) {
+    fun updateState(
+        width: Int,
+        height: Int,
+        headerHeight: Int,
+    ) {
         val realWidth: Float = PixelUtil.toDIPFromPixel(width.toFloat())
         val realHeight: Float = PixelUtil.toDIPFromPixel(height.toFloat())
+        val realHeaderHeight: Float = PixelUtil.toDIPFromPixel(headerHeight.toFloat())
 
         // Check incoming state values. If they're already the correct value, return early to prevent
         // infinite UpdateState/SetState loop.
-        val currentState: ReadableMap? = mFabricViewStateManager.getStateData()
-        if (currentState != null) {
-            val delta = 0.9f
-            val stateFrameHeight: Float = if (currentState.hasKey("frameHeight")) currentState.getDouble("frameHeight").toFloat() else 0f
-            val stateFrameWidth: Float = if (currentState.hasKey("frameWidth")) currentState.getDouble("frameWidth").toFloat() else 0f
-            if (abs(stateFrameWidth - realWidth) < delta &&
-                abs(stateFrameHeight - realHeight) < delta
-            ) {
-                return
-            }
-        }
-        mFabricViewStateManager.setState {
-            val map: WritableMap = WritableNativeMap()
-            map.putDouble("frameWidth", realWidth.toDouble())
-            map.putDouble("frameHeight", realHeight.toDouble())
-            map
+        val delta = 0.9f
+        if (abs(lastSetWidth - realWidth) < delta &&
+            abs(lastSetHeight - realHeight) < delta
+        ) {
+            return
         }
+
+        lastSetWidth = realWidth
+        lastSetHeight = realHeight
+        val map: WritableMap =
+            WritableNativeMap().apply {
+                putDouble("frameWidth", realWidth.toDouble())
+                putDouble("frameHeight", realHeight.toDouble())
+                putDouble("contentOffsetX", 0.0)
+                putDouble("contentOffsetY", realHeaderHeight.toDouble())
+            }
+        mStateWrapper?.updateState(map)
     }
 }

package/android/src/fabric/java/com/swmansion/rnscreens/NativeProxy.kt

@@ -0,0 +1,53 @@
+package com.swmansion.rnscreens
+
+import android.util.Log
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.fabric.FabricUIManager
+import java.lang.ref.WeakReference
+import java.util.concurrent.ConcurrentHashMap
+
+class NativeProxy {
+    @DoNotStrip
+    @Suppress("unused")
+    private val mHybridData: HybridData
+
+    init {
+        mHybridData = initHybrid()
+    }
+
+    private external fun initHybrid(): HybridData
+
+    external fun nativeAddMutationsListener(fabricUIManager: FabricUIManager)
+
+    companion object {
+        // we use ConcurrentHashMap here since it will be read on the JS thread,
+        // and written to on the UI thread.
+        private val viewsMap = ConcurrentHashMap<Int, WeakReference<Screen>>()
+
+        fun addScreenToMap(
+            tag: Int,
+            view: Screen,
+        ) {
+            viewsMap[tag] = WeakReference(view)
+        }
+
+        fun removeScreenFromMap(tag: Int) {
+            viewsMap.remove(tag)
+        }
+
+        fun clearMapOnInvalidate() {
+            viewsMap.clear()
+        }
+    }
+
+    @DoNotStrip
+    public fun notifyScreenRemoved(screenTag: Int) {
+        val screen = viewsMap[screenTag]?.get()
+        if (screen is Screen) {
+            screen.startRemovalTransition()
+        } else {
+            Log.w("[RNScreens]", "Did not find view with tag $screenTag.")
+        }
+    }
+}

package/android/src/main/cpp/NativeProxy.cpp

@@ -0,0 +1,51 @@
+#include <fbjni/fbjni.h>
+#include <react/fabric/Binding.h>
+#include <react/renderer/scheduler/Scheduler.h>
+
+#include <string>
+
+#include "NativeProxy.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace rnscreens {
+
+NativeProxy::NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis)
+    : javaPart_(jni::make_global(jThis)) {}
+
+NativeProxy::~NativeProxy() {}
+
+void NativeProxy::registerNatives() {
+  registerHybrid(
+      {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
+       makeNativeMethod(
+           "nativeAddMutationsListener",
+           NativeProxy::nativeAddMutationsListener)});
+}
+
+void NativeProxy::nativeAddMutationsListener(
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager) {
+  auto uiManager =
+      fabricUIManager->getBinding()->getScheduler()->getUIManager();
+  screenRemovalListener_ =
+      std::make_shared<RNSScreenRemovalListener>([this](int tag) {
+        static const auto method =
+            javaPart_->getClass()->getMethod<void(jint)>("notifyScreenRemoved");
+        method(javaPart_, tag);
+      });
+
+  uiManager->getShadowTreeRegistry().enumerate(
+      [this](const facebook::react::ShadowTree &shadowTree, bool &stop) {
+        shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+            screenRemovalListener_);
+      });
+}
+
+jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
+    jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+} // namespace rnscreens

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

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/JFabricUIManager.h>
+#include "RNSScreenRemovalListener.h"
+
+#include <string>
+
+namespace rnscreens {
+using namespace facebook;
+using namespace facebook::jni;
+
+class NativeProxy : public jni::HybridClass<NativeProxy> {
+ public:
+  std::shared_ptr<RNSScreenRemovalListener> screenRemovalListener_;
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/rnscreens/NativeProxy;";
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis);
+  static void registerNatives();
+
+  ~NativeProxy();
+
+ private:
+  friend HybridBase;
+  jni::global_ref<NativeProxy::javaobject> javaPart_;
+
+  explicit NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis);
+
+  void nativeAddMutationsListener(
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager);
+};
+
+} // namespace rnscreens

package/android/src/main/cpp/OnLoad.cpp

@@ -0,0 +1,8 @@
+#include <fbjni/fbjni.h>
+
+#include "NativeProxy.h"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(
+      vm, [] { rnscreens::NativeProxy::registerNatives(); });
+}

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

@@ -0,0 +1,106 @@
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <array>
+#include <mutex>
+#include "RNScreensTurboModule.h"
+
+using namespace facebook;
+
+jobject globalThis;
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_swmansion_rnscreens_ScreensModule_nativeInstall(
+    JNIEnv *env,
+    jobject thiz,
+    jlong jsiPtr) {
+  auto runtime = reinterpret_cast<jsi::Runtime *>(jsiPtr);
+  if (!runtime) {
+    return;
+  }
+  jsi::Runtime &rt = *runtime;
+  if (globalThis) {
+    env->DeleteGlobalRef(globalThis);
+  }
+  globalThis = env->NewGlobalRef(thiz);
+  JavaVM *jvm;
+  env->GetJavaVM(&jvm);
+
+  const auto &startTransition = [jvm](int stackTag) -> std::array<int, 2> {
+    JNIEnv *currentEnv;
+    if (jvm->AttachCurrentThread(&currentEnv, nullptr) != JNI_OK) {
+      return {0, 0};
+    }
+    jclass javaClass = currentEnv->GetObjectClass(globalThis);
+    jmethodID methodID = currentEnv->GetMethodID(
+        javaClass, "startTransition", "(Ljava/lang/Integer;)[I");
+    jclass integerClass = currentEnv->FindClass("java/lang/Integer");
+    jmethodID integerConstructor =
+        currentEnv->GetMethodID(integerClass, "<init>", "(I)V");
+    jobject integerArg =
+        currentEnv->NewObject(integerClass, integerConstructor, stackTag);
+    jintArray resultArray = (jintArray)currentEnv->CallObjectMethod(
+        globalThis, methodID, integerArg);
+    std::array<int, 2> result = {-1, -1};
+    jint *elements = currentEnv->GetIntArrayElements(resultArray, nullptr);
+    if (elements != nullptr) {
+      result[0] = elements[0];
+      result[1] = elements[1];
+      currentEnv->ReleaseIntArrayElements(resultArray, elements, JNI_ABORT);
+    }
+    return result;
+  };
+
+  const auto &updateTransition = [jvm](int stackTag, double progress) {
+    JNIEnv *currentEnv;
+    if (jvm->AttachCurrentThread(&currentEnv, nullptr) != JNI_OK) {
+      return;
+    }
+    jclass javaClass = currentEnv->GetObjectClass(globalThis);
+    jmethodID methodID =
+        currentEnv->GetMethodID(javaClass, "updateTransition", "(D)V");
+    currentEnv->CallVoidMethod(globalThis, methodID, progress);
+  };
+
+  const auto &finishTransition = [jvm](int stackTag, bool canceled) {
+    JNIEnv *currentEnv;
+    if (jvm->AttachCurrentThread(&currentEnv, nullptr) != JNI_OK) {
+      return;
+    }
+    jclass javaClass = currentEnv->GetObjectClass(globalThis);
+    jmethodID methodID = currentEnv->GetMethodID(
+        javaClass, "finishTransition", "(Ljava/lang/Integer;Z)V");
+    jclass integerClass = currentEnv->FindClass("java/lang/Integer");
+    jmethodID integerConstructor =
+        currentEnv->GetMethodID(integerClass, "<init>", "(I)V");
+    jobject integerArg =
+        currentEnv->NewObject(integerClass, integerConstructor, stackTag);
+    currentEnv->CallVoidMethod(globalThis, methodID, integerArg, canceled);
+  };
+
+  const auto &disableSwipeBackForTopScreen = [](int _stackTag) {
+    // no implementation for Android
+  };
+
+  auto rnScreensModule = std::make_shared<RNScreens::RNScreensTurboModule>(
+      startTransition,
+      updateTransition,
+      finishTransition,
+      disableSwipeBackForTopScreen);
+  auto rnScreensModuleHostObject =
+      jsi::Object::createFromHostObject(rt, rnScreensModule);
+  rt.global().setProperty(
+      rt,
+      RNScreens::RNScreensTurboModule::MODULE_NAME,
+      std::move(rnScreensModuleHostObject));
+}
+
+void JNICALL JNI_OnUnload(JavaVM *jvm, void *) {
+  JNIEnv *env;
+  if (jvm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
+    return;
+  }
+  if (globalThis != nullptr) {
+    env->DeleteGlobalRef(globalThis);
+    globalThis = nullptr;
+  }
+}