react-native-pointr 8.16.1 → 9.2.0

package/android/src/main/java/com/pointr/PTRMapWidgetManager.kt

@@ -1,8 +1,6 @@
 package com.pointr
 
 import android.annotation.SuppressLint
-import android.os.Handler
-import android.os.Looper.getMainLooper
 import android.util.Log
 import android.view.Choreographer
 import android.view.View
@@ -15,36 +13,32 @@ import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.events.RCTEventEmitter
-import com.pointrlabs.core.configuration.MutableConfiguration
 import com.pointrlabs.core.management.DataManager
 import com.pointrlabs.core.management.Pointr
 import com.pointrlabs.core.management.interfaces.PointrListener
 import com.pointrlabs.core.management.models.ErrorMessage
+import com.pointrlabs.core.management.models.PTRParams
 import com.pointrlabs.core.management.models.Site
-import com.pointrlabs.core.map.handlers.MapWidgetEventsHandler
-import com.pointrlabs.core.map.handlers.PathFindingEventsHandler
-import com.pointrlabs.core.map.handlers.PathUpdatesEventHandler
-import com.pointrlabs.core.map.models.PTRDeepLinkAction
-import com.pointrlabs.core.map.models.PTRDeepLinkLocation
-import com.pointrlabs.core.map.models.PTRDeepLinkPathfindingAction
-import com.pointrlabs.core.map.models.PTRDeepLinkPoiLocation
-import com.pointrlabs.core.map.models.PTRError
-import com.pointrlabs.core.map.models.PTRMapSymbolLayer
-import com.pointrlabs.core.map.models.events_listeners.MapEventsListener
-import com.pointrlabs.core.map.models.events_listeners.MarkMyCarDetailsEvent
-import com.pointrlabs.core.map.models.events_listeners.MarkMyCarDetailsEventsListener
-import com.pointrlabs.core.map.models.events_listeners.PathFindingEventsListener
-import com.pointrlabs.core.map.viewmodels.PTRMapWidgetConfiguration
-import com.pointrlabs.core.map.views.PTRMapAnimationType
-import com.pointrlabs.core.map.views.PTRMapFragment
-import com.pointrlabs.core.map.views.PTRMapWidgetFragment
-import com.pointrlabs.core.map.views.pathfinding.MarkMyCarBottomSheet
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetAction
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetBuildingLocation
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetFocusAction
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetLevelLocation
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetMarkMyCarAction
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetPoiLocation
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetShowMyCarAction
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetSiteLocation
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetWayfindingAction
 import com.pointrlabs.core.nativecore.wrappers.Plog
-import com.pointrlabs.core.pathfinding.PathManager
-import com.pointrlabs.core.pathfinding.session.PathSession
-import com.pointrlabs.core.pathfinding.session.PathSessionState
-import com.pointrlabs.core.positioning.model.PositioningTypes
 import com.pointrlabs.core.site.SiteManager
+import com.pointrlabs.core.util.models.error.PTRError
+import com.pointrlabs.core.wayfinding.WayfindingManager
+import com.pointrlabs.ui.map.models.PTRMapSymbolLayer
+import com.pointrlabs.ui.map.models.events_listeners.MapEventsListener
+import com.pointrlabs.ui.map.models.events_listeners.MarkMyCarDetailsEvent
+import com.pointrlabs.ui.map.models.events_listeners.MarkMyCarDetailsEventsListener
+import com.pointrlabs.ui.map.views.PTRMapFragment
+import com.pointrlabs.ui.map.views.PTRMapWidgetFragment
+import com.pointrlabs.ui.map.views.wayfinding.MarkMyCarBottomSheet
 import java.util.concurrent.Semaphore
 
 
@@ -54,36 +48,20 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
 
     override fun getName() = REACT_CLASS
 
-    private var markMyCarButtonSheet: MarkMyCarBottomSheet? = null
     private lateinit var frameLayout: FrameLayout
 
-    // TODO: Uncomment 1
-    // private var _ptrMapWidgetFragment: PTRMapWidgetFragment? = null
-    private val ptrMapWidgetFragment: PTRMapWidgetFragment?
-        get() {
-            // TODO: Uncomment 1
-            // _ptrMapWidgetFragment?.let { return it }
-            Log.i("PTRMapWidgetManager", "Creating map widget fragment")
-            // TODO: Uncomment 1
-            //_ptrMapWidgetFragment = createMapWidgetFragment()
-            // TODO: Comment 1
-            val _ptrMapWidgetFragment = createMapWidgetFragment()
-            Choreographer.getInstance().postFrameCallback(frameCallback)
-            _ptrMapWidgetFragment?.addListener(this)
-            return _ptrMapWidgetFragment
-        }
-
-    private fun createMapWidgetFragment(): PTRMapWidgetFragment {
+    private fun getMapWidgetFragment(action: PTRMapWidgetAction): PTRMapWidgetFragment {
+        Log.i("PTRMapWidgetManager", "Creating map widget fragment with action: $action")
         waitForPointrToRun()
-        // TODO: wait for configuration to be ready
-        val configuration = PointrMapWidgetActivity.mapWidgetConfiguration
-        configuration.isExitButtonShown = false
-        @Suppress("DEPRECATION")
-        val widget = PTRMapWidgetFragment.newInstance(configuration).show(
+        val ptrMapWidgetFragment = PTRMapWidgetFragment.newInstance(
             (reactContext.currentActivity as FragmentActivity).supportFragmentManager,
-            frameLayout.id
+            frameLayout.id,
+            PointrModule.mapWidgetConfiguration,
+            action
         )
-        return widget
+        Choreographer.getInstance().postFrameCallback(frameCallback)
+        ptrMapWidgetFragment.addListener(this)
+        return ptrMapWidgetFragment
     }
 
     /**
@@ -102,182 +80,167 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
     ) {
         super.receiveCommand(root, command, args)
         val args1 = args ?: return
-        val ptrMapWidgetFragment = this.ptrMapWidgetFragment ?: run {
-            Log.e(
-                "PTRMapWidgetManager",
-                "PTRMapWidgetFragment is null"
-            )
-            return
-        }
-        // TODO: Uncomment 1
-//        clearPath(ptrMapWidgetFragment)
-//        dismissMarkMyCarDetails(ptrMapWidgetFragment)
-        executeCommand(ptrMapWidgetFragment, command, args1)
-    }
-
-    private fun dismissMarkMyCarDetails(ptrMapWidgetFragment: PTRMapWidgetFragment) {
-        val markMyCarButtonSheet = markMyCarButtonSheet ?: return
-        val handler = ptrMapWidgetFragment.markMyCarEventsHandler
-            ?: return Plog.w("Mark my car events handler is null")
-        Plog.i("Dismissing mark my car details")
-        handler.onMarkMyCarDetailsEvent(markMyCarButtonSheet, MarkMyCarDetailsEvent.Cancel)
-        handler.onMarkMyCarDetailsEvent(markMyCarButtonSheet, MarkMyCarDetailsEvent.Close)
-    }
-
-    private fun clearPath(ptrMapWidgetFragment: PTRMapWidgetFragment) {
-        ptrMapWidgetFragment.mapFragment?.removeAllFeatures { isSuccess, message ->
-            if (!isSuccess) {
-                Log.e(
-                    "PTRMapWidgetManager",
-                    "Error removing features: $message"
-                )
-            }
-            ptrMapWidgetFragment.mapFragment?.removeLayer(LAYER_STATIC_PATH) { b, e ->
-                if (!b) {
-                    Log.e(
-                        "PTRMapWidgetManager",
-                        "Error removing layer: $e"
-                    )
-                }
-                ptrMapWidgetFragment.mapFragment?.currentPath = null
-                ptrMapWidgetFragment.mapFragment?.currentPathSession?.abort()
-            }
-        }
+        executeCommand(command, args1)
     }
 
     private fun executeCommand(
-        ptrMapWidgetFragment: PTRMapWidgetFragment,
         command: String,
-        args1: ReadableArray
+        args: ReadableArray
     ) {
-        when (command) {
-            PTRMapWidgetCommandType.SITE -> showSite(ptrMapWidgetFragment, args1.getString(0))
-            PTRMapWidgetCommandType.BUILDING -> showBuilding(
-                ptrMapWidgetFragment,
-                args1.getString(0),
-                args1.getString(1)
-            )
+        val action: PTRMapWidgetAction = when (command) {
+            PTRMapWidgetCommandType.SITE -> {
+                val siteId = args.getString(0).orEmpty()
+                val location = PTRMapWidgetSiteLocation(siteId, isExternalIdentifier = true)
+                PTRMapWidgetFocusAction(location)
+            }
 
-            PTRMapWidgetCommandType.LEVEL -> showLevel(
-                ptrMapWidgetFragment,
-                args1.getString(0),
-                args1.getString(1),
-                args1.getInt(2)
-            )
+            PTRMapWidgetCommandType.BUILDING -> {
+                val siteId = args.getString(0).orEmpty()
+                val buildingId = args.getString(1).orEmpty()
+                val location =
+                    PTRMapWidgetBuildingLocation(siteId, buildingId, isExternalIdentifier = true)
+                PTRMapWidgetFocusAction(location)
+            }
 
-            PTRMapWidgetCommandType.POI -> showPoi(
-                ptrMapWidgetFragment,
-                args1.getString(0),
-                args1.getString(1)
-            )
+            PTRMapWidgetCommandType.LEVEL -> {
+                val siteId = args.getString(0).orEmpty()
+                val buildingId = args.getString(1).orEmpty()
+                val location = PTRMapWidgetLevelLocation(
+                    siteId,
+                    buildingId,
+                    args.getInt(2),
+                    isExternalIdentifier = true
+                )
+                PTRMapWidgetFocusAction(location)
+            }
 
-            PTRMapWidgetCommandType.PATH -> showPath(
-                ptrMapWidgetFragment,
-                args1.getString(0),
-                args1.getString(1)
-            )
+            PTRMapWidgetCommandType.POI -> {
+                val siteId = args.getString(0).orEmpty()
+                val poiId = args.getString(1).orEmpty()
+                val location = PTRMapWidgetPoiLocation(siteId, poiId, isExternalIdentifier = true)
+                PTRMapWidgetFocusAction(location)
+            }
 
-            PTRMapWidgetCommandType.STATIC_PATH -> showStaticPath(
-                ptrMapWidgetFragment,
-                args1.getString(0),
-                args1.getString(1),
-                args1.getString(2)
-            )
+            PTRMapWidgetCommandType.PATH -> {
+                val siteId = args.getString(0).orEmpty()
+                val poiId = args.getString(1).orEmpty()
+                val location = PTRMapWidgetPoiLocation(siteId, poiId, isExternalIdentifier = true)
+                PTRMapWidgetWayfindingAction(location)
+            }
+
+            PTRMapWidgetCommandType.STATIC_PATH -> {
+                val siteId = args.getString(0).orEmpty()
+                val fromPoiId = args.getString(1).orEmpty()
+                val toPoiId = args.getString(2).orEmpty()
+                val location =
+                    PTRMapWidgetPoiLocation(siteId, fromPoiId, isExternalIdentifier = true)
+                val action1 = PTRMapWidgetFocusAction(location)
+                val ptrMapWidgetFragment = getMapWidgetFragment(action1)
+                action1.onComplete = onComplete@{ error ->
+                    if (error != null) {
+                        mapWidgetDidEndLoading(
+                            command,
+                            *args.toArrayList().mapNotNull { it }.toTypedArray(),
+                            error
+                        )
+                        return@onComplete
+                    }
+                    Plog.i("Focus action completed, showing static path")
+
+                    showStaticPath(
+                        ptrMapWidgetFragment,
+                        siteId,
+                        fromPoiId,
+                        toPoiId
+                    )
+                }
+                return
+            }
 
             PTRMapWidgetCommandType.MARK_MY_CAR_SITE -> {
-                showMarkMyCarDetails(
-                    ptrMapWidgetFragment,
-                    args1.getString(0),
-                    shouldShowPopup = args1.getBoolean(1),
-                    animationType = args1.getInt(2)
-                )
+                val siteId = args.getString(0).orEmpty()
+                val location = PTRMapWidgetSiteLocation(siteId, isExternalIdentifier = true)
+                PTRMapWidgetMarkMyCarAction(location, shouldShowPopup = args.getBoolean(1))
             }
 
             PTRMapWidgetCommandType.MARK_MY_CAR_LEVEL -> {
-                showMarkMyCarDetails(
-                    ptrMapWidgetFragment,
-                    args1.getString(0),
-                    args1.getString(1),
-                    args1.getInt(2),
-                    args1.getBoolean(3),
-                    args1.getInt(4)
+                val siteId = args.getString(0).orEmpty()
+                val location = PTRMapWidgetLevelLocation(
+                    siteId,
+                    args.getString(1).orEmpty(),
+                    args.getInt(2),
+                    isExternalIdentifier = true
                 )
+                PTRMapWidgetMarkMyCarAction(location, shouldShowPopup = args.getBoolean(3))
             }
 
-            PTRMapWidgetCommandType.MY_CAR_SITE -> {
-                showMyCarDetails(ptrMapWidgetFragment, args1.getString(0), args1.getInt(1))
+            PTRMapWidgetCommandType.SHOW_MY_CAR_SITE -> {
+                val siteId = args.getString(0).orEmpty()
+                val location = PTRMapWidgetSiteLocation(siteId, isExternalIdentifier = true)
+                PTRMapWidgetShowMyCarAction(location, shouldShowPopup = args.getBoolean(1))
             }
 
-            else -> return
-        }
-    }
+            PTRMapWidgetCommandType.START_AND_FOCUS -> {
+                // First 4 parameters are initialization parameters
+                val clientId = args.getString(0).orEmpty()
+                val licenceKey = args.getString(1).orEmpty()
+                val baseUrl = args.getString(2).orEmpty()
+                val logLevel = args.getInt(3)
+
+                val ptrParams = PTRParams(clientId, licenceKey, baseUrl)
+                ptrParams.logLevel = try {
+                    Plog.LogLevel.entries[logLevel]
+                } catch (_: IllegalArgumentException) {
+                    Plog.LogLevel.ERROR
+                }
+                PointrModule.mapWidgetConfiguration.sdkParams = ptrParams
 
-    private fun showMyCarDetails(
-        ptrMapWidgetFragment: PTRMapWidgetFragment,
-        siteExternalIdentifier: String,
-        animationTypeOrdinal: Int
-    ) {
-        val animationType = PTRMapAnimationType.entries[animationTypeOrdinal]
-        ptrMapWidgetFragment.showMyCarDetails(
-            siteExternalIdentifier,
-            shouldShowDialog = false,
-            animationType = animationType
-        ) onComplete@{ error ->
-            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.MY_CAR_SITE,
-                siteExternalIdentifier,
-                animationType,
-                error ?: ""
-            )
-            error?.let {
-                Plog.e("Error showing mark my car details: $it")
-                return@onComplete
+                // Next parameter is focus type (site, building, level, poi)
+                val focusType = args.getString(4).orEmpty()
+
+                // Create focus action based on type
+                val location = when (focusType) {
+                    PTRMapWidgetCommandType.SITE -> {
+                        val siteId = args.getString(5).orEmpty()
+                        PTRMapWidgetSiteLocation(siteId, isExternalIdentifier = true)
+                    }
+                    PTRMapWidgetCommandType.BUILDING -> {
+                        val siteId = args.getString(5).orEmpty()
+                        val buildingId = args.getString(6).orEmpty()
+                        PTRMapWidgetBuildingLocation(siteId, buildingId, isExternalIdentifier = true)
+                    }
+                    PTRMapWidgetCommandType.LEVEL -> {
+                        val siteId = args.getString(5).orEmpty()
+                        val buildingId = args.getString(6).orEmpty()
+                        val levelIndex = args.getInt(7)
+                        PTRMapWidgetLevelLocation(siteId, buildingId, levelIndex, isExternalIdentifier = true)
+                    }
+                    PTRMapWidgetCommandType.POI -> {
+                        val siteId = args.getString(5).orEmpty()
+                        val poiId = args.getString(6).orEmpty()
+                        PTRMapWidgetPoiLocation(siteId, poiId, isExternalIdentifier = true)
+                    }
+                    else -> {
+                        // Default to site if invalid focus type
+                        val siteId = args.getString(5).orEmpty()
+                        PTRMapWidgetSiteLocation(siteId, isExternalIdentifier = true)
+                    }
+                }
+                PTRMapWidgetFocusAction(location)
             }
-            Plog.i("Mark my car details is shown")
-        }
-    }
 
-    private fun showMarkMyCarDetails(
-        ptrMapWidgetFragment: PTRMapWidgetFragment,
-        siteExternalIdentifier: String,
-        buildingExternalIdentifier: String? = null,
-        levelIndex: Int? = null,
-        shouldShowPopup: Boolean,
-        animationType: Int
-    ) {
+            else -> return
+        }
+        action.onComplete = { error ->
+            val list = args.toArrayList()
+            list.add(error ?: "")
 
-        ptrMapWidgetFragment.showMarkMyCarDetails(
-            siteExternalIdentifier,
-            buildingExternalIdentifier,
-            levelIndex,
-            PTRMapAnimationType.entries[animationType],
-            shouldShowPopup
-        ) onComplete@{ error ->
-            if (buildingExternalIdentifier == null || levelIndex == null || levelIndex == PositioningTypes.INVALID_INTEGER) {
-                this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                    PTRMapWidgetCommandType.MARK_MY_CAR_LEVEL,
-                    siteExternalIdentifier,
-                    buildingExternalIdentifier ?: "",
-                    levelIndex ?: PositioningTypes.INVALID_INTEGER,
-                    shouldShowPopup,
-                    animationType,
-                    error ?: ""
-                )
-            } else {
-                this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                    PTRMapWidgetCommandType.MARK_MY_CAR_SITE,
-                    siteExternalIdentifier,
-                    shouldShowPopup,
-                    animationType,
-                    error ?: ""
-                )
-            }
-            error?.let {
-                Plog.e("Error showing mark my car details: $it")
-                return@onComplete
-            }
-            Plog.i("Mark my car details is shown")
+            mapWidgetDidEndLoading(
+                command,
+                *list.mapNotNull { it }.toTypedArray(),
+            )
         }
+        getMapWidgetFragment(action)
     }
 
     private fun mapWidgetDidEndLoading(
@@ -301,7 +264,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
             PTRMapWidgetCommandType.LEVEL -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("buildingExternalIdentifier", args[1] as String)
-                event.putInt("levelIndex", args[2] as Int)
+                event.putInt("levelIndex", (args[2] as Number).toInt())
                 event.putString("error", args[3] as String)
             }
 
@@ -324,6 +287,66 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 event.putString("error", args[3] as String)
             }
 
+            PTRMapWidgetCommandType.MARK_MY_CAR_SITE -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putBoolean("shouldShowPopup", args[1] as Boolean)
+                event.putInt("animationType", (args[2] as Number).toInt())
+                event.putString("error", args[3] as String)
+            }
+
+            PTRMapWidgetCommandType.MARK_MY_CAR_LEVEL -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putString("buildingExternalIdentifier", args[1] as String)
+                event.putInt("levelIndex", (args[2] as Number).toInt())
+                event.putBoolean("shouldShowPopup", args[3] as Boolean)
+                event.putInt("animationType", (args[4] as Number).toInt())
+                event.putString("error", args[5] as String)
+            }
+
+            PTRMapWidgetCommandType.SHOW_MY_CAR_SITE -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putBoolean("shouldShowPopup", args[1] as Boolean)
+                event.putInt("animationType", (args[2] as Number).toInt())
+                event.putString("error", args[3] as String)
+            }
+
+            PTRMapWidgetCommandType.START_AND_FOCUS -> {
+                event.putString("clientId", args[0] as String)
+                event.putString("licenceKey", args[1] as String)
+                event.putString("baseUrl", args[2] as String)
+                event.putInt("logLevel", (args[3] as Number).toInt())
+                event.putString("focusType", args[4] as String)
+
+                // Add focus-specific parameters based on focus type
+                val focusType = args[4] as String
+                when (focusType) {
+                    PTRMapWidgetCommandType.SITE -> {
+                        event.putString("siteExternalIdentifier", args[5] as String)
+                        event.putString("error", args.last().toString())
+                    }
+                    PTRMapWidgetCommandType.BUILDING -> {
+                        event.putString("siteExternalIdentifier", args[5] as String)
+                        event.putString("buildingExternalIdentifier", args[6] as String)
+                        event.putString("error", args.last().toString())
+                    }
+                    PTRMapWidgetCommandType.LEVEL -> {
+                        event.putString("siteExternalIdentifier", args[5] as String)
+                        event.putString("buildingExternalIdentifier", args[6] as String)
+                        event.putInt("levelIndex", (args[7] as Number).toInt())
+                        event.putString("error", args.last().toString())
+                    }
+                    PTRMapWidgetCommandType.POI -> {
+                        event.putString("siteExternalIdentifier", args[5] as String)
+                        event.putString("poiExternalIdentifier", args[6] as String)
+                        event.putString("error", args.last().toString())
+                    }
+                    else -> {
+                        event.putString("siteExternalIdentifier", args[5] as String)
+                        event.putString("error", args.last().toString())
+                    }
+                }
+            }
+
             else -> {
                 return
             }
@@ -404,7 +427,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
             )
             return
         }
-        val pathManager = Pointr.getPointr()?.pathManager ?: run {
+        val wayfindingManager = Pointr.getPointr()?.wayfindingManager ?: run {
             mapWidgetDidEndLoading(
                 PTRMapWidgetCommandType.STATIC_PATH,
                 site,
@@ -414,7 +437,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
             )
             return
         }
-        val path = pathManager.calculatePath(source, listOf(target)) ?: run {
+        val route = wayfindingManager.calculateRoute(source, listOf(target)) ?: run {
             mapWidgetDidEndLoading(
                 PTRMapWidgetCommandType.STATIC_PATH,
                 site,
@@ -424,217 +447,66 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
             )
             return
         }
-        val onCompleted = { error: String? ->
-            error?.let {
+        val layer = PTRMapSymbolLayer(
+            LAYER_STATIC_PATH
+        )
+        ptrMapWidgetFragment.mapFragment?.addLayer(layer) { isSuccess, message ->
+            if (!isSuccess) {
                 mapWidgetDidEndLoading(
                     PTRMapWidgetCommandType.STATIC_PATH,
                     site,
                     fromPoi,
                     toPoi,
-                    "Error loading the map: $it"
+                    "Failed to add static path layer: $message"
                 )
-                Plog.e("Error showing level: $it")
-                return@let
+                return@addLayer
             }
-            ptrMapWidgetFragment.focusOnCoordinate(
-                source.location.site?.internalIdentifier ?: PositioningTypes.INVALID_INTEGER,
-                source.location.building?.internalIdentifier ?: PositioningTypes.INVALID_INTEGER,
-                source.location.level?.index ?: PositioningTypes.INVALID_INTEGER,
-                source.location.lat,
-                source.location.lon
-            ) {
-                val layer = PTRMapSymbolLayer(LAYER_STATIC_PATH)
-                val mapFragment = ptrMapWidgetFragment.mapFragment ?: return@focusOnCoordinate
-                mapFragment.addLayer(layer) { b1, e1 ->
-                    if (!b1) {
-                        mapWidgetDidEndLoading(
-                            PTRMapWidgetCommandType.STATIC_PATH,
-                            site,
-                            fromPoi,
-                            toPoi,
-                            "Error adding layer: $e1"
-                        )
-                        Plog.e("Error adding layer: $e1")
-                        return@addLayer
-                    }
-                    mapFragment.addFeatures(
-                        listOf(source, target), layer.identifier
-                    ) { b2, e2 ->
-                        if (!b2) {
-                            mapWidgetDidEndLoading(
-                                PTRMapWidgetCommandType.STATIC_PATH,
-                                site,
-                                fromPoi,
-                                toPoi,
-                                "Error adding features: $e2"
-                            )
-                            Plog.e("Error adding features: $e2")
-                            return@addFeatures
-                        }
-                        mapFragment.currentPath = path
-                        mapWidgetDidEndLoading(
-                            PTRMapWidgetCommandType.STATIC_PATH,
-                            site,
-                            fromPoi,
-                            toPoi,
-                            ""
-                        )
-                        Plog.i("Path shown")
-                    }
+            Log.i("PTRMapWidgetManager", "Static path layer added successfully")
+
+            ptrMapWidgetFragment.mapFragment?.addFeatures(
+                listOf(source, target),
+                LAYER_STATIC_PATH
+            ) { isSuccess1, message1 ->
+                if (!isSuccess1) {
+                    mapWidgetDidEndLoading(
+                        PTRMapWidgetCommandType.STATIC_PATH,
+                        site,
+                        fromPoi,
+                        toPoi,
+                        "Failed to add POI features: $message1"
+                    )
+                    return@addFeatures
                 }
-            }
-        }
-        source.level?.let {
-            ptrMapWidgetFragment.showLevel(it, onComplete = onCompleted)
-        } ?: ptrMapWidgetFragment.showSite(
-            source.location.site?.internalIdentifier ?: 0, onComplete = onCompleted
-        )
-
-    }
-
-    private fun showPath(ptrMapWidgetFragment: PTRMapWidgetFragment, site: String, toPoi: String) {
-
-
-        val siteObject = getSite(site) ?: run {
-            mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.PATH,
-                site,
-                toPoi,
-                "Site not found"
-            )
-            return
-        }
-        if (!waitForSiteData(siteObject)) {
-            mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.PATH,
-                site,
-                toPoi,
-                "Site data not found"
-            )
-            return
-        }
-        val target =
-            Pointr.getPointr()?.poiManager?.getPoiByExternalIdentifier(siteObject, toPoi) ?: run {
+                Log.i("PTRMapWidgetManager", "POI features added successfully")
+                ptrMapWidgetFragment.mapFragment?.currentRoute = route
                 mapWidgetDidEndLoading(
-                    PTRMapWidgetCommandType.PATH,
+                    PTRMapWidgetCommandType.STATIC_PATH,
                     site,
+                    fromPoi,
                     toPoi,
-                    "Target POI not found"
+                    ""
                 )
-                return
-            }
-
-        val action = PTRDeepLinkPathfindingAction(
-            PTRDeepLinkPoiLocation(
-                siteObject.internalIdentifier,
-                target.id
-            )
-        )
-        ptrMapWidgetFragment.performDeepLinkAction(action) { error ->
-            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.PATH,
-                site,
-                toPoi,
-                error ?: ""
-            )
-            error?.let {
-                Plog.e("Error showing path: $it")
-                return@performDeepLinkAction
-            }
-            Plog.i("Path shown")
-        }
-    }
-
-    private fun showPoi(ptrMapWidgetFragment: PTRMapWidgetFragment, site: String, poi: String) {
-        ptrMapWidgetFragment.showPoiDetails(site, poi) { error ->
-            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.POI,
-                site,
-                poi,
-                error ?: ""
-            )
-            error?.let {
-                Plog.e("Error showing poi: $it")
-                return@showPoiDetails
-            }
-            Plog.i("Poi shown")
-        }
-    }
-
-    private fun showLevel(
-        ptrMapWidgetFragment: PTRMapWidgetFragment,
-        site: String,
-        building: String,
-        level: Int
-    ) {
-        ptrMapWidgetFragment.showLevel(site, building, level) showLevelInternal@{ error ->
-            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.LEVEL,
-                site,
-                building,
-                level,
-                error ?: ""
-            )
-            error?.let {
-                Plog.e("Error showing level: $it")
-                return@showLevelInternal
-            }
-            Plog.i("Level shown")
-        }
-    }
-
-    private fun showBuilding(
-        ptrMapWidgetFragment: PTRMapWidgetFragment,
-        site: String,
-        building: String
-    ) {
-        ptrMapWidgetFragment.showBuilding(site, building) showBuildingInternal@{ error ->
-            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.BUILDING,
-                site,
-                building,
-                error ?: ""
-            )
-            error?.let {
-                Plog.e("Error showing building: $it")
-                return@showBuildingInternal
-            }
-            Plog.i("Building shown")
-        }
-    }
-
-    private fun showSite(ptrMapWidgetFragment: PTRMapWidgetFragment, site: String) {
-        ptrMapWidgetFragment.showSite(site) showSiteInternal@{ error ->
-            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.SITE,
-                site,
-                error ?: ""
-            )
-            error?.let {
-                Plog.e("Error showing site: $it")
-                return@showSiteInternal
             }
-            Plog.i("Site shown")
         }
     }
 
     // region Show path
 
     private fun waitForPathManager(theSite: Site): Boolean {
-        val pathManager = Pointr.getPointr()?.pathManager ?: return false
+        val wayfindingManager = Pointr.getPointr()?.wayfindingManager ?: return false
         val semaphore = Semaphore(0)
-        val listener = object : PathManager.Listener {
-            override fun onPathManagerReadyForSite(site: Site) {
+        val listener = object : WayfindingManager.Listener {
+            override fun onWayfindingManagerReadyForSite(site: Site) {
                 if (site != theSite) return
                 semaphore.release()
             }
         }
-        pathManager.addListener(listener)
-        if (!pathManager.isReadyForSite(theSite)) {
+        wayfindingManager.addListener(listener)
+        if (!wayfindingManager.isReadyForSite(theSite)) {
             semaphore.tryAcquire(15, java.util.concurrent.TimeUnit.SECONDS)
         }
-        pathManager.removeListener(listener)
-        return pathManager.isReadyForSite(theSite)
+        wayfindingManager.removeListener(listener)
+        return wayfindingManager.isReadyForSite(theSite)
     }
 
     private fun waitForSiteData(theSite: Site): Boolean {
@@ -661,7 +533,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         return Pointr.getPointr()?.poiManager?.hasContentForSite(theSite) == true
     }
 
-    private fun getSite(site: String): Site? {
+    private fun getSite(siteExternalId: String): Site? {
         val siteManager = Pointr.getPointr()?.siteManager ?: return null
         val semaphore = Semaphore(0)
         val listener = object : SiteManager.Listener {
@@ -670,11 +542,11 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
             }
         }
         siteManager.addListener(listener)
-        if (siteManager.getSites().isEmpty()) {
+        if (siteManager.sites.isEmpty()) {
             semaphore.tryAcquire(10, java.util.concurrent.TimeUnit.SECONDS)
         }
         siteManager.removeListener(listener)
-        return siteManager.getSite(site)
+        return siteManager.getSiteByExternalIdentifier(siteExternalId)
     }
 
     // endregion
@@ -748,7 +620,6 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         markMyCarDetailsEvent: MarkMyCarDetailsEvent
     ) {
         super.onMarkMyCarDetailsEvent(markMyCarSheet, markMyCarDetailsEvent)
-        this.markMyCarButtonSheet = markMyCarSheet
         Plog.i("Mark my car details event: $markMyCarDetailsEvent")
     }