React-Native 0.80.1 NavigationTurboModule.kt 284 Line

[ertugruldogan]

Fatal Exception: java.lang.RuntimeException Unable to pause activity {.MainActivity}: java.lang.NullPointerException: null cannot be cast to non-null type com.reactnativenavigation.NavigationActivity
Caused by java.lang.NullPointerException null cannot be cast to non-null type com.reactnativenavigation.NavigationActivity com.reactnativenavigation.react.NavigationTurboModule.activity (NavigationTurboModule.kt:284)

node_modules\react-native-navigation\lib\android\app\src\main\java\com\reactnativenavigation\react\NavigationTurboModule.kt

---

It is called in (NavigationTurboModule.kt), where the activity is either null or a reference to an activity that has not yet been connected to the screen.

ReactContext.currentActivity may return null in some cases — especially:

If the activity is just being created,

If the application is in splash mode,

If the lifecycle is transitioning quickly (e.g., very fast launch + pause),

Or if the system calls onPause during the animation.

Example of error resolution:

package com.reactnativenavigation.react

import android.util.Log
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReadableArray
import com.facebook.react.bridge.ReadableMap
import com.reactnativenavigation.NavigationActivity
import com.reactnativenavigation.NavigationApplication
import com.reactnativenavigation.options.LayoutFactory
import com.reactnativenavigation.options.Options
import com.reactnativenavigation.options.parsers.JSONParser
import com.reactnativenavigation.options.parsers.LayoutNodeParser
import com.reactnativenavigation.options.parsers.TypefaceLoader
import com.reactnativenavigation.react.events.EventEmitter
import com.reactnativenavigation.utils.LaunchArgsParser
import com.reactnativenavigation.utils.Now
import com.reactnativenavigation.utils.SystemUiUtils.getStatusBarHeight
import com.reactnativenavigation.utils.UiThread
import com.reactnativenavigation.utils.UiUtils
import com.reactnativenavigation.viewcontrollers.navigator.Navigator
import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController
import java.util.Objects

class NavigationTurboModule(
    reactContext: ReactApplicationContext,
    private val layoutFactory: LayoutFactory
) : NativeRNNTurboModuleSpec(reactContext) {

    private val now = Now()
    private val jsonParser: JSONParser = JSONParser()
    private lateinit var eventEmitter: EventEmitter
    private var currentNavigationActivity: NavigationActivity? = null

    init {
        reactContext.addLifecycleEventListener(object : LifecycleEventListenerAdapter() {
            override fun onHostPause() {
                super.onHostPause()
                currentNavigationActivity = null
                UiUtils.runOnMainThread {
                    navigator()?.onHostPause()
                }
            }

            override fun onHostResume() {
                currentNavigationActivity = reactApplicationContext.currentActivity as? NavigationActivity
                eventEmitter = EventEmitter(reactContext)
                val nav = navigator()
                val act = activity()
                if (nav != null && act != null) {
                    nav.setEventEmitter(eventEmitter)
                    layoutFactory.init(
                        act,
                        eventEmitter,
                        nav.getChildRegistry(),
                        (act.application as NavigationApplication).externalComponents
                    )
                    UiUtils.runOnMainThread { nav.onHostResume() }
                }
            }
        })
    }

    override fun getTypedExportedConstants(): MutableMap<String, Any> {
        val constants = mutableMapOf<String, Any>()
        val act = activity()
        constants[Constants.BACK_BUTTON_JS_KEY] = Constants.BACK_BUTTON_ID
        constants[Constants.BOTTOM_TABS_HEIGHT_KEY] =
            UiUtils.pxToDp(
                reactApplicationContext,
                UiUtils.getBottomTabsHeight(reactApplicationContext).toFloat()
            ).toDouble()
        constants[Constants.STATUS_BAR_HEIGHT_KEY] =
            act?.let { UiUtils.pxToDp(reactApplicationContext, getStatusBarHeight(it).toFloat()).toDouble() }
                ?: 0.0
        constants[Constants.TOP_BAR_HEIGHT_KEY] = UiUtils.pxToDp(
            reactApplicationContext,
            UiUtils.getTopBarHeight(reactApplicationContext).toFloat()
        ).toDouble()
        return constants
    }

    override fun setRoot(commandId: String, layout: ReadableMap, promise: Promise) {
        Log.d("NavigationTurboModule", "setRoot ${Thread.currentThread()}")
        val layoutTree = LayoutNodeParser.parse(
            Objects.requireNonNull(
                jsonParser.parse(layout).optJSONObject("root")
            )
        )
        handle {
            Log.d("NavigationTurboModule", "setRoot handle ${Thread.currentThread()}")
            val viewController = layoutFactory.create(layoutTree)
            navigator()?.setRoot(
                viewController,
                NativeCommandListener("setRoot", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun setDefaultOptions(options: ReadableMap?) {
        handle {
            val defaultOptions = parse(options)
            layoutFactory.defaultOptions = defaultOptions
            navigator()?.let { it.defaultOptions = defaultOptions }
        }
    }

    override fun mergeOptions(componentId: String?, options: ReadableMap?) {
        handle { navigator()?.mergeOptions(componentId, parse(options)) }
    }

    override fun push(
        commandId: String,
        componentId: String,
        layout: ReadableMap,
        promise: Promise
    ) {
        val layoutTree = LayoutNodeParser.parse(jsonParser.parse(layout))
        handle {
            val viewController = layoutFactory.create(layoutTree)
            navigator()?.push(
                componentId,
                viewController,
                NativeCommandListener("push", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun pop(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            navigator()?.pop(
                componentId,
                parse(options),
                NativeCommandListener("pop", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun popTo(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            navigator()?.popTo(
                componentId,
                parse(options),
                NativeCommandListener("popTo", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun popToRoot(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            navigator()?.popToRoot(
                componentId,
                parse(options),
                NativeCommandListener("popToRoot", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun setStackRoot(
        commandId: String,
        componentId: String,
        children: ReadableArray,
        promise: Promise
    ) {
        handle {
            val _children = ArrayList<ViewController<*>>()
            for (i in 0..<children.size()) {
                val layoutTree = LayoutNodeParser.parse(jsonParser.parse(children.getMap(i)))
                _children.add(layoutFactory.create(layoutTree))
            }
            navigator()?.setStackRoot(
                componentId,
                _children,
                NativeCommandListener("setStackRoot", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun showModal(commandId: String, layout: ReadableMap, promise: Promise) {
        val layoutTree = LayoutNodeParser.parse(jsonParser.parse(layout))
        handle {
            val viewController = layoutFactory.create(layoutTree)
            navigator()?.showModal(
                viewController,
                NativeCommandListener("showModal", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun dismissModal(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            navigator()?.mergeOptions(componentId, parse(options))
            navigator()?.dismissModal(
                componentId,
                NativeCommandListener("dismissModal", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun dismissAllModals(commandId: String, options: ReadableMap?, promise: Promise) {
        handle {
            navigator()?.dismissAllModals(
                parse(options),
                NativeCommandListener("dismissAllModals", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun showOverlay(commandId: String, layout: ReadableMap, promise: Promise) {
        val layoutTree = LayoutNodeParser.parse(jsonParser.parse(layout))
        handle {
            val viewController = layoutFactory.create(layoutTree)
            navigator()?.showOverlay(
                viewController,
                NativeCommandListener("showOverlay", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun dismissOverlay(commandId: String, componentId: String, promise: Promise) {
        handle {
            navigator()?.dismissOverlay(
                componentId,
                NativeCommandListener("dismissOverlay", commandId, promise, eventEmitter, now)
            )
        }
    }

    override fun dismissAllOverlays(commandId: String, promise: Promise) {
        handle {
            navigator()?.dismissAllOverlays(
                NativeCommandListener(
                    "dismissAllOverlays",
                    commandId,
                    promise,
                    eventEmitter,
                    now
                )
            )
        }
    }

    override fun getLaunchArgs(commandId: String, promise: Promise) {
        val act = activity()
        if (act != null) {
            promise.resolve(LaunchArgsParser.parse(act))
        } else {
            promise.reject("ACTIVITY_NOT_AVAILABLE", "Activity not available")
        }
    }

    private fun parse(mergeOptions: ReadableMap?): Options {
        val ctx = reactApplicationContext
        return if (mergeOptions == null) {
            Options.EMPTY
        } else {
            val activity = activity()
            val typefaceLoader = if (activity != null) {
                TypefaceLoader(activity)
            } else {
                // Fallback to context if activity is not available
                TypefaceLoader(ctx)
            }
            Options.parse(
                ctx,
                typefaceLoader,
                jsonParser.parse(mergeOptions)
            )
        }
    }

    private fun navigator(): Navigator? {
        return activity()?.navigator
    }

    private fun handle(task: Runnable) {
        UiThread.post {
            val activity = activity()
            if (activity != null && !activity.isFinishing) {
                task.run()
            } else {
                Log.w("NavigationTurboModule", "Activity not available or finishing, skipping task")
            }
        }
    }

    private fun activity(): NavigationActivity? {
        val current = reactApplicationContext.currentActivity as? NavigationActivity
        if (current != null && current != currentNavigationActivity) {
            currentNavigationActivity = current
        }
        return currentNavigationActivity
    }

    companion object {
        const val NAME = "RNNTurboModule"
    }
}

React Native Navigation version: 8.1.0
React Native version: 0.80.1
Has Fabric (React Native's new rendering system) enabled: (yes/no) YES

[merteroglu]

Same problem

React Native Navigation version: 8.1.1
React Native version: 0.77.3
Has Fabric (React Native's new rendering system) enabled: (yes/no) YES

edit

I solved my issue — thanks to Gemini. I was keeping my custom native modules directly in the project's package.json. Gemini pointed out that this structure might conflict with React Native Navigation, and suggested moving the turbo modules to a separate folder, like a lib, and integrating them into the app from there. After that, the issue was resolved.

[gosha212]

unfortunately the problem is deeper @merteroglu
Steps to reproduce:

1. Launch the app before the metro bundler in dev mode
2. Launch the metro bundler
3. Reload the app on the device

[ertugruldogan]

We're seeing this issue in the Google Play Store. It's very difficult to spot in regular testing.

I have updated it as follows, of course it may not be enough.
But now the error does not appear in the Google Play Store.

This is the final version.
node_modules\react-native-navigation\lib\android\app\src\main\java\com\reactnativenavigation\react\NavigationTurboModule.kt

package com.reactnativenavigation.react

import android.util.Log
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReadableArray
import com.facebook.react.bridge.ReadableMap
import com.reactnativenavigation.NavigationActivity
import com.reactnativenavigation.NavigationApplication
import com.reactnativenavigation.options.LayoutFactory
import com.reactnativenavigation.options.Options
import com.reactnativenavigation.options.parsers.JSONParser
import com.reactnativenavigation.options.parsers.LayoutNodeParser
import com.reactnativenavigation.options.parsers.TypefaceLoader
import com.reactnativenavigation.react.events.EventEmitter
import com.reactnativenavigation.utils.LaunchArgsParser
import com.reactnativenavigation.utils.Now
import com.reactnativenavigation.utils.SystemUiUtils.getStatusBarHeight
import com.reactnativenavigation.utils.UiThread
import com.reactnativenavigation.utils.UiUtils
import com.reactnativenavigation.viewcontrollers.navigator.Navigator
import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController
import java.util.Objects

class NavigationTurboModule(
    reactContext: ReactApplicationContext,
    private val layoutFactory: LayoutFactory
) : NativeRNNTurboModuleSpec(reactContext) {

    private val now = Now()
    private val jsonParser: JSONParser = JSONParser()
    private lateinit var eventEmitter: EventEmitter
    @Volatile
    private var currentNavigationActivity: NavigationActivity? = null

    init {
        reactContext.addLifecycleEventListener(object : LifecycleEventListenerAdapter() {
            override fun onHostPause() {
                super.onHostPause()
                currentNavigationActivity = null
                UiUtils.runOnMainThread {
                    navigator()?.onHostPause()
                }
            }

            override fun onHostResume() {
                try {
                    val currentActivity = reactApplicationContext.currentActivity as? NavigationActivity
                    if (currentActivity == null || currentActivity.isFinishing || currentActivity.isDestroyed) {
                        Log.w("NavigationTurboModule", "onHostResume: currentActivity is null, finishing, or destroyed")
                        return
                    }
                    
                    currentNavigationActivity = currentActivity
                    eventEmitter = EventEmitter(reactContext)
                    val nav = navigator()
                    val act = activity()
                    if (nav != null && act != null && !act.isFinishing && !act.isDestroyed) {
                        nav.setEventEmitter(eventEmitter)
                        layoutFactory.init(
                            act,
                            eventEmitter,
                            nav.getChildRegistry(),
                            (act.application as NavigationApplication).externalComponents
                        )
                        UiUtils.runOnMainThread { nav.onHostResume() }
                    }
                } catch (e: Exception) {
                    Log.e("NavigationTurboModule", "Error in onHostResume: ${e.message}", e)
                }
            }
        })
    }

    override fun getTypedExportedConstants(): MutableMap<String, Any> {
        val constants = mutableMapOf<String, Any>()
        try {
            val act = activity()
            constants[Constants.BACK_BUTTON_JS_KEY] = Constants.BACK_BUTTON_ID
            constants[Constants.BOTTOM_TABS_HEIGHT_KEY] =
                UiUtils.pxToDp(
                    reactApplicationContext,
                    UiUtils.getBottomTabsHeight(reactApplicationContext).toFloat()
                ).toDouble()
            constants[Constants.STATUS_BAR_HEIGHT_KEY] =
                act?.let { 
                    try {
                        UiUtils.pxToDp(reactApplicationContext, getStatusBarHeight(it).toFloat()).toDouble()
                    } catch (e: Exception) {
                        Log.e("NavigationTurboModule", "Error getting status bar height", e)
                        0.0
                    }
                } ?: 0.0
            constants[Constants.TOP_BAR_HEIGHT_KEY] = UiUtils.pxToDp(
                reactApplicationContext,
                UiUtils.getTopBarHeight(reactApplicationContext).toFloat()
            ).toDouble()
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "Error in getTypedExportedConstants", e)
        }
        return constants
    }

    override fun setRoot(commandId: String, layout: ReadableMap, promise: Promise) {
        Log.d("NavigationTurboModule", "setRoot ${Thread.currentThread()}")
        try {
            val layoutTree = LayoutNodeParser.parse(
                Objects.requireNonNull(
                    jsonParser.parse(layout).optJSONObject("root")
                )
            )
            handle {
                try {
                    Log.d("NavigationTurboModule", "setRoot handle ${Thread.currentThread()}")
                    val viewController = layoutFactory.create(layoutTree)
                    navigator()?.setRoot(
                        viewController,
                        NativeCommandListener("setRoot", commandId, promise, eventEmitter, now)
                    )
                } catch (e: Exception) {
                    Log.e("NavigationTurboModule", "Error in setRoot task: ${e.message}", e)
                    promise.reject("SETROOT_ERROR", "Error in setRoot: ${e.message}")
                }
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "setRoot error: ${e.message}", e)
            promise.reject("SETROOT_ERROR", "Error in setRoot: ${e.message}")
        }
    }

    override fun setDefaultOptions(options: ReadableMap?) {
        handle {
            try {
                val defaultOptions = parse(options)
                layoutFactory.defaultOptions = defaultOptions
                navigator()?.let { it.defaultOptions = defaultOptions }
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in setDefaultOptions: ${e.message}", e)
            }
        }
    }

    override fun mergeOptions(componentId: String?, options: ReadableMap?) {
        handle { 
            try {
                navigator()?.mergeOptions(componentId, parse(options))
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in mergeOptions: ${e.message}", e)
            }
        }
    }

    override fun push(
        commandId: String,
        componentId: String,
        layout: ReadableMap,
        promise: Promise
    ) {
        try {
            val layoutTree = LayoutNodeParser.parse(jsonParser.parse(layout))
            handle {
                try {
                    val viewController = layoutFactory.create(layoutTree)
                    navigator()?.push(
                        componentId,
                        viewController,
                        NativeCommandListener("push", commandId, promise, eventEmitter, now)
                    )
                } catch (e: Exception) {
                    Log.e("NavigationTurboModule", "Error in push task: ${e.message}", e)
                    promise.reject("PUSH_ERROR", "Error in push: ${e.message}")
                }
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "push error: ${e.message}", e)
            promise.reject("PUSH_ERROR", "Error in push: ${e.message}")
        }
    }

    override fun pop(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            try {
                navigator()?.pop(
                    componentId,
                    parse(options),
                    NativeCommandListener("pop", commandId, promise, eventEmitter, now)
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in pop: ${e.message}", e)
                promise.reject("POP_ERROR", "Error in pop: ${e.message}")
            }
        }
    }

    override fun popTo(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            try {
                navigator()?.popTo(
                    componentId,
                    parse(options),
                    NativeCommandListener("popTo", commandId, promise, eventEmitter, now)
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in popTo: ${e.message}", e)
                promise.reject("POPTO_ERROR", "Error in popTo: ${e.message}")
            }
        }
    }

    override fun popToRoot(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            try {
                navigator()?.popToRoot(
                    componentId,
                    parse(options),
                    NativeCommandListener("popToRoot", commandId, promise, eventEmitter, now)
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in popToRoot: ${e.message}", e)
                promise.reject("POPTOROOT_ERROR", "Error in popToRoot: ${e.message}")
            }
        }
    }

    override fun setStackRoot(
        commandId: String,
        componentId: String,
        children: ReadableArray,
        promise: Promise
    ) {
        handle {
            try {
                val _children = ArrayList<ViewController<*>>()
                for (i in 0..<children.size()) {
                    val layoutTree = LayoutNodeParser.parse(jsonParser.parse(children.getMap(i)))
                    _children.add(layoutFactory.create(layoutTree))
                }
                navigator()?.setStackRoot(
                    componentId,
                    _children,
                    NativeCommandListener("setStackRoot", commandId, promise, eventEmitter, now)
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in setStackRoot: ${e.message}", e)
                promise.reject("SETSTACKROOT_ERROR", "Error in setStackRoot: ${e.message}")
            }
        }
    }

    override fun showModal(commandId: String, layout: ReadableMap, promise: Promise) {
        try {
            val layoutTree = LayoutNodeParser.parse(jsonParser.parse(layout))
            handle {
                try {
                    val viewController = layoutFactory.create(layoutTree)
                    navigator()?.showModal(
                        viewController,
                        NativeCommandListener("showModal", commandId, promise, eventEmitter, now)
                    )
                } catch (e: Exception) {
                    Log.e("NavigationTurboModule", "Error in showModal task: ${e.message}", e)
                    promise.reject("SHOWMODAL_ERROR", "Error in showModal: ${e.message}")
                }
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "showModal error: ${e.message}", e)
            promise.reject("SHOWMODAL_ERROR", "Error in showModal: ${e.message}")
        }
    }

    override fun dismissModal(
        commandId: String,
        componentId: String,
        options: ReadableMap?,
        promise: Promise
    ) {
        handle {
            try {
                navigator()?.mergeOptions(componentId, parse(options))
                navigator()?.dismissModal(
                    componentId,
                    NativeCommandListener("dismissModal", commandId, promise, eventEmitter, now)
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in dismissModal: ${e.message}", e)
                promise.reject("DISMISSMODAL_ERROR", "Error in dismissModal: ${e.message}")
            }
        }
    }

    override fun dismissAllModals(commandId: String, options: ReadableMap?, promise: Promise) {
        handle {
            try {
                navigator()?.dismissAllModals(
                    parse(options),
                    NativeCommandListener("dismissAllModals", commandId, promise, eventEmitter, now)
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in dismissAllModals: ${e.message}", e)
                promise.reject("DISMISSALLMODALS_ERROR", "Error in dismissAllModals: ${e.message}")
            }
        }
    }

    override fun showOverlay(commandId: String, layout: ReadableMap, promise: Promise) {
        try {
            val layoutTree = LayoutNodeParser.parse(jsonParser.parse(layout))
            handle {
                try {
                    val viewController = layoutFactory.create(layoutTree)
                    navigator()?.showOverlay(
                        viewController,
                        NativeCommandListener("showOverlay", commandId, promise, eventEmitter, now)
                    )
                } catch (e: Exception) {
                    Log.e("NavigationTurboModule", "Error in showOverlay task: ${e.message}", e)
                    promise.reject("SHOWOVERLAY_ERROR", "Error in showOverlay: ${e.message}")
                }
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "showOverlay error: ${e.message}", e)
            promise.reject("SHOWOVERLAY_ERROR", "Error in showOverlay: ${e.message}")
        }
    }

    override fun dismissOverlay(commandId: String, componentId: String, promise: Promise) {
        handle {
            try {
                navigator()?.dismissOverlay(
                    componentId,
                    NativeCommandListener("dismissOverlay", commandId, promise, eventEmitter, now)
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in dismissOverlay: ${e.message}", e)
                promise.reject("DISMISSOVERLAY_ERROR", "Error in dismissOverlay: ${e.message}")
            }
        }
    }

    override fun dismissAllOverlays(commandId: String, promise: Promise) {
        handle {
            try {
                navigator()?.dismissAllOverlays(
                    NativeCommandListener(
                        "dismissAllOverlays",
                        commandId,
                        promise,
                        eventEmitter,
                        now
                    )
                )
            } catch (e: Exception) {
                Log.e("NavigationTurboModule", "Error in dismissAllOverlays: ${e.message}", e)
                promise.reject("DISMISSALLOVERLAYS_ERROR", "Error in dismissAllOverlays: ${e.message}")
            }
        }
    }

    override fun getLaunchArgs(commandId: String, promise: Promise) {
        try {
            val act = activity()
            if (act != null && !act.isFinishing && !act.isDestroyed) {
                promise.resolve(LaunchArgsParser.parse(act))
            } else {
                promise.reject("ACTIVITY_NOT_AVAILABLE", "Activity not available")
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "Error in getLaunchArgs: ${e.message}", e)
            promise.reject("GETLAUNCHARGS_ERROR", "Error in getLaunchArgs: ${e.message}")
        }
    }

    private fun parse(mergeOptions: ReadableMap?): Options {
        return try {
            val ctx = reactApplicationContext
            if (mergeOptions == null) {
                Options.EMPTY
            } else {
                val activity = activity()
                val typefaceLoader = if (activity != null && !activity.isFinishing && !activity.isDestroyed) {
                    TypefaceLoader(activity)
                } else {
                    TypefaceLoader(ctx)
                }
                Options.parse(
                    ctx,
                    typefaceLoader,
                    jsonParser.parse(mergeOptions)
                )
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "Error in parse: ${e.message}", e)
            Options.EMPTY
        }
    }

    private fun navigator(): Navigator? {
        return try {
            activity()?.navigator
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "Error getting navigator: ${e.message}", e)
            null
        }
    }

    private fun handle(task: Runnable) {
        try {
            UiThread.post {
                val activity = activity()
                if (activity != null && !activity.isFinishing && !activity.isDestroyed) {
                    try {
                        task.run()
                    } catch (e: Exception) {
                        Log.e("NavigationTurboModule", "Error executing task: ${e.message}", e)
                    }
                } else {
                    Log.w("NavigationTurboModule", "Activity not available, finishing, or destroyed. Skipping task.")
                }
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "Error in handle: ${e.message}", e)
        }
    }

    private fun activity(): NavigationActivity? {
        return try {
            val current = reactApplicationContext.currentActivity as? NavigationActivity
            if (current != null && current != currentNavigationActivity && !current.isFinishing && !current.isDestroyed) {
                currentNavigationActivity = current
            }
            
            if (currentNavigationActivity?.isFinishing == false && currentNavigationActivity?.isDestroyed == false) {
                currentNavigationActivity
            } else {
                null
            }
        } catch (e: Exception) {
            Log.e("NavigationTurboModule", "Error getting activity: ${e.message}", e)
            null
        }
    }

    companion object {
        const val NAME = "RNNTurboModule"
    }
}

[ramaerion]

@ertugruldogan have you managed to run react-native-navigation on ios also with version of 0.80.1 ?

[ertugruldogan]

@ertugruldogan have you managed to run react-native-navigation on ios also with version of 0.80.1 ?

YES, it works on both 0.80.1 and 0.81.1 on ANDROID.

[ramaerion]

I also managed it to work on Android . I was wondering if you also managed it to run on ios with either verson 0.80 or 0.81.

[ertugruldogan]

I also managed it to work on Android . I was wondering if you also managed it to run on ios with either verson 0.80 or 0.81.

IOS newArchEnabled=false, hermesEnabled=true RNN 7.45.0 and RN 0.80.x or 0.81.x It works like this

newArchEnabled=true - RNN 8.3.1+ There are still problems with iOS.

#8026 (comment)