react-native-pointr 9.9.0 → 10.0.0

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

@@ -14,43 +14,37 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.uimanager.events.RCTEventEmitter
-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.management.models.deeplink.PTRIdentifier
 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.PTRMapWidgetCoordinateLocation
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetFocusMapAction
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetHighlightCategoryAction
+import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetHighlightPoiAction
 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.PTRMapWidgetStaticWayfindingAction
-import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetWayfindingAction
 import com.pointrlabs.core.nativecore.wrappers.Plog
 import com.pointrlabs.core.poi.models.Poi
 import com.pointrlabs.core.site.SiteManager
 import com.pointrlabs.core.util.models.error.PTRError
-import com.pointrlabs.core.wayfinding.WayfindingManager
-import com.pointrlabs.core.wayfinding.session.RouteSession
-import com.pointrlabs.core.wayfinding.session.RouteSessionState
-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.models.events_listeners.MapWidgetEventsListener
 import com.pointrlabs.ui.map.models.events_listeners.WayfindingEventsListener
 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
 
 
 @SuppressLint("LogNotTimber")
 class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
-    ViewGroupManager<FrameLayout>(), MapEventsListener, MarkMyCarDetailsEventsListener, WayfindingEventsListener {
+    ViewGroupManager<FrameLayout>(), MapEventsListener, WayfindingEventsListener, MapWidgetEventsListener {
 
     override fun getName() = REACT_CLASS
 
@@ -61,22 +55,21 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
     // Declarative prop support -----------------------------------------------
     // When a `command` JSON prop is passed on <PTRMapWidget />, the manager
     // auto-executes it once the view is attached rather than requiring a JS
-    // imperative command dispatch.
+    // imperative action dispatch.
     //
-    // JSON shape: { "type": "site"|"building"|"level"|"poi"|"path"|"staticPath"|"staticWayfinding",
+    // JSON shape: { "type": "focusMap"|"highlightPoi"|"displayRoute"|"startWayfinding"|"markMyCar"|"showMyCar"|"focusCoordinate"|"highlightCategory",
     //               "site": String, "building"?: String, "level"?: Int,
-    //               "poi"?: String, "fromPoi"?: String, "toPoi"?: String,
-    //               "sourcePoi"?: String, "destinationPoi"?: String }
-    private var pendingCommandJson: String? = null
+    //               "poi"?: String, "fromPoi"?: String, "toPoi"?: String }
+    private var pendingActionJson: String? = null
     private var pendingSdkConfigJson: String? = null
-    private var commandDidExecute = false
+    private var actionDidExecute = false
     // Reset per view instance in createViewInstance so re-navigation works.
-    private var commandTriggered = false
+    private var actionTriggered = false
 
-    @ReactProp(name = "command")
-    fun setCommand(view: FrameLayout, commandJson: String?) {
-        pendingCommandJson = commandJson
-        commandDidExecute = false
+    @ReactProp(name = "action")
+    fun setAction(view: FrameLayout, actionJson: String?) {
+        pendingActionJson = actionJson
+        actionDidExecute = false
     }
 
     @ReactProp(name = "sdkConfig")
@@ -90,7 +83,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         if (configJson == null) return
         try {
             val obj = org.json.JSONObject(configJson)
-            val cfg = PointrModule.mapWidgetConfiguration
+            val cfg = PTRNativeLibrary.mapWidgetConfiguration
             cfg::class.members.filterIsInstance<kotlin.reflect.KMutableProperty1<*, *>>().forEach { prop ->
                 val jsonKey = if (prop.name == "isBuildingLevelSelectorEnabled") "isLevelSelectorEnabled" else prop.name
                 if (!obj.has(jsonKey)) return@forEach
@@ -120,7 +113,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 } catch (_: Exception) {
                     Plog.LogLevel.ERROR
                 }
-                PointrModule.mapWidgetConfiguration.sdkParams = params
+                PTRNativeLibrary.mapWidgetConfiguration.sdkParams = params
                 // Initialize the Pointr SDK if it has not been initialized yet
                 // (covers the case where sdkConfig is used without a prior pointrSdk.initialize() call).
                 if (Pointr.getPointr() == null) {
@@ -133,9 +126,9 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
     }
 
     private fun executePendingCommandIfNeeded() {
-        val json = pendingCommandJson ?: return
-        if (commandDidExecute) return
-        commandDidExecute = true
+        val json = pendingActionJson ?: return
+        if (actionDidExecute) return
+        actionDidExecute = true
         Thread {
             // Block on background thread until Pointr is running (semaphore wait).
             // If Pointr never reaches RUNNING (e.g. SDK not initialized), skip entirely
@@ -160,43 +153,67 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                     val poi = obj.optString("poi", "")
                     val fromPoi = obj.optString("fromPoi", "")
                     val toPoi = obj.optString("toPoi", "")
-                    val sourcePoi = obj.optString("sourcePoi", "")
-                    val destinationPoi = obj.optString("destinationPoi", "")
 
                     val args = com.facebook.react.bridge.Arguments.createArray()
+                    val shouldShowPopup = obj.optBoolean("shouldShowPopup", true)
                     when (type) {
-                        PTRMapWidgetCommandType.SITE -> {
-                            args.pushString(site)
-                            executeCommand(PTRMapWidgetCommandType.SITE, args)
+                        PTRMapWidgetActionType.FOCUS_MAP -> {
+                            if (building.isNotEmpty() && obj.has("level")) {
+                                args.pushString(site); args.pushString(building); args.pushInt(level)
+                                executeCommand("level", args)
+                            } else if (building.isNotEmpty()) {
+                                args.pushString(site); args.pushString(building)
+                                executeCommand("building", args)
+                            } else {
+                                args.pushString(site)
+                                executeCommand("site", args)
+                            }
                         }
-                        PTRMapWidgetCommandType.BUILDING -> {
-                            args.pushString(site); args.pushString(building)
-                            executeCommand(PTRMapWidgetCommandType.BUILDING, args)
+                        PTRMapWidgetActionType.HIGHLIGHT_POI -> {
+                            args.pushString(site); args.pushString(poi)
+                            executeCommand("poi", args)
                         }
-                        PTRMapWidgetCommandType.LEVEL -> {
-                            args.pushString(site); args.pushString(building); args.pushInt(level)
-                            executeCommand(PTRMapWidgetCommandType.LEVEL, args)
+                        PTRMapWidgetActionType.DISPLAY_ROUTE -> {
+                            args.pushString(site); args.pushString(fromPoi); args.pushString(toPoi)
+                            executeCommand(PTRMapWidgetActionType.DISPLAY_ROUTE, args)
                         }
-                        PTRMapWidgetCommandType.POI -> {
-                            args.pushString(site); args.pushString(poi)
-                            executeCommand(PTRMapWidgetCommandType.POI, args)
+                        PTRMapWidgetActionType.START_WAYFINDING -> {
+                            args.pushString(site); args.pushString(toPoi)
+                            executeCommand(PTRMapWidgetActionType.START_WAYFINDING, args)
                         }
-                        PTRMapWidgetCommandType.PATH -> {
-                            args.pushString(site); args.pushString(poi)
-                            executeCommand(PTRMapWidgetCommandType.PATH, args)
+                        PTRMapWidgetActionType.MARK_MY_CAR -> {
+                            if (building.isNotEmpty() && obj.has("level")) {
+                                args.pushString(site); args.pushString(building); args.pushInt(level); args.pushBoolean(shouldShowPopup)
+                                executeCommand("markMyCarForLevel", args)
+                            } else {
+                                args.pushString(site); args.pushBoolean(shouldShowPopup)
+                                executeCommand("markMyCarForSite", args)
+                            }
                         }
-                        PTRMapWidgetCommandType.STATIC_PATH -> {
-                            args.pushString(site); args.pushString(fromPoi); args.pushString(toPoi)
-                            executeCommand(PTRMapWidgetCommandType.STATIC_PATH, args)
+                        PTRMapWidgetActionType.SHOW_MY_CAR -> {
+                            args.pushString(site); args.pushBoolean(shouldShowPopup)
+                            executeCommand("showMyCarForSite", args)
+                        }
+                        PTRMapWidgetActionType.FOCUS_COORDINATE -> {
+                            val lat = obj.optDouble("latitude", 0.0)
+                            val lon = obj.optDouble("longitude", 0.0)
+                            val lvl = obj.optInt("levelIndex", -1)
+                            args.pushString(site); args.pushDouble(lat); args.pushDouble(lon); args.pushInt(lvl)
+                            executeCommand(PTRMapWidgetActionType.FOCUS_COORDINATE, args)
                         }
-                        PTRMapWidgetCommandType.STATIC_WAYFINDING -> {
-                            args.pushString(site); args.pushString(sourcePoi); args.pushString(destinationPoi)
-                            executeCommand(PTRMapWidgetCommandType.STATIC_WAYFINDING, args)
+                        PTRMapWidgetActionType.HIGHLIGHT_CATEGORY -> {
+                            val catArr = com.facebook.react.bridge.Arguments.createArray()
+                            val jsonArr = obj.optJSONArray("categoryIds")
+                            if (jsonArr != null) {
+                                for (i in 0 until jsonArr.length()) catArr.pushString(jsonArr.optString(i))
+                            }
+                            args.pushString(site); args.pushArray(catArr)
+                            executeCommand(PTRMapWidgetActionType.HIGHLIGHT_CATEGORY, args)
                         }
-                        else -> Log.w(name, "Unknown command type in command prop: $type")
+                        else -> Log.w(name, "Unknown action type in action prop: $type")
                     }
                 } catch (e: Exception) {
-                    Log.e(name, "Failed to execute command prop: ${e.message}")
+                    Log.e(name, "Failed to execute action prop: ${e.message}")
                 }
             }
         }.start()
@@ -215,7 +232,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         ptrMapWidgetFragment = PTRMapWidgetFragment.newInstance(
             (reactContext.currentActivity as FragmentActivity).supportFragmentManager,
             frameLayout.id,
-            PointrModule.mapWidgetConfiguration,
+            PTRNativeLibrary.mapWidgetConfiguration,
             action
         )
         Choreographer.getInstance().postFrameCallback(frameCallback)
@@ -231,9 +248,9 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         ptrMapWidgetFragment?.removeListener(this)
         ptrMapWidgetFragment = null
         frameLayout = FrameLayout(reactContext)
-        commandDidExecute = false
-        commandTriggered = false  // reset so re-navigation triggers the command again
-        // Start the frame loop immediately so the declarative command prop can
+        actionDidExecute = false
+        actionTriggered = false  // reset so re-navigation triggers the command again
+        // Start the frame loop immediately so the declarative action prop can
         // fire once the view has been measured and laid out by React Native.
         Choreographer.getInstance().postFrameCallback(frameCallback)
         return frameLayout
@@ -255,154 +272,115 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         args: ReadableArray
     ) {
         val action: PTRMapWidgetAction = when (command) {
-            PTRMapWidgetCommandType.SITE -> {
+            "site" -> {
                 val siteId = args.getString(0).orEmpty()
-                val location = PTRMapWidgetSiteLocation(siteId, isExternal = true)
-                PTRMapWidgetFocusAction(location)
+                val location = PTRMapWidgetSiteLocation(PTRIdentifier(siteId, isExternal = true))
+                PTRMapWidgetAction.focusMap(location)
             }
 
-            PTRMapWidgetCommandType.BUILDING -> {
+            "building" -> {
                 val siteId = args.getString(0).orEmpty()
                 val buildingId = args.getString(1).orEmpty()
-                val location =
-                    PTRMapWidgetBuildingLocation(siteId, buildingId, isExternalIdentifier = true)
-                PTRMapWidgetFocusAction(location)
+                val location = PTRMapWidgetBuildingLocation(
+                    PTRIdentifier(siteId, isExternal = true),
+                    PTRIdentifier(buildingId, isExternal = true)
+                )
+                PTRMapWidgetAction.focusMap(location)
             }
 
-            PTRMapWidgetCommandType.LEVEL -> {
+            "level" -> {
                 val siteId = args.getString(0).orEmpty()
                 val buildingId = args.getString(1).orEmpty()
                 val location = PTRMapWidgetLevelLocation(
-                    siteId,
-                    buildingId,
-                    args.getInt(2),
-                    isExternalIdentifier = true
+                    PTRIdentifier(siteId, isExternal = true),
+                    PTRIdentifier(buildingId, isExternal = true),
+                    args.getInt(2)
                 )
-                PTRMapWidgetFocusAction(location)
+                PTRMapWidgetAction.focusMap(location)
             }
 
-            PTRMapWidgetCommandType.POI -> {
+            "poi" -> {
                 val siteId = args.getString(0).orEmpty()
                 val poiId = args.getString(1).orEmpty()
-                val location = PTRMapWidgetPoiLocation(siteId, poiId, isExternalIdentifier = true)
-                PTRMapWidgetFocusAction(location)
+                val location = PTRMapWidgetPoiLocation(
+                    PTRIdentifier(siteId, isExternal = true),
+                    PTRIdentifier(poiId, isExternal = true)
+                )
+                PTRMapWidgetAction.highlightPoi(location)
             }
 
-            PTRMapWidgetCommandType.PATH -> {
+            PTRMapWidgetActionType.START_WAYFINDING -> {
                 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
-                    }
-                    Log.i(name, "Focus action completed, showing static path")
-
-                    showStaticPath(
-                        ptrMapWidgetFragment,
-                        siteId,
-                        fromPoiId,
-                        toPoiId
-                    )
-                }
-                return
+                val location = PTRMapWidgetPoiLocation(
+                    PTRIdentifier(siteId, isExternal = true),
+                    PTRIdentifier(poiId, isExternal = true)
+                )
+                PTRMapWidgetAction.startWayfinding(location)
             }
 
-            PTRMapWidgetCommandType.STATIC_WAYFINDING -> {
+            PTRMapWidgetActionType.DISPLAY_ROUTE -> {
                 val siteId = args.getString(0).orEmpty()
                 val sourcePoiId = args.getString(1).orEmpty()
                 val destinationPoiId = args.getString(2).orEmpty()
-                val sourceLocation = PTRMapWidgetPoiLocation(siteId, sourcePoiId, isExternalIdentifier = true)
-                val destinationLocation = PTRMapWidgetPoiLocation(siteId, destinationPoiId, isExternalIdentifier = true)
-                PTRMapWidgetStaticWayfindingAction(sourceLocation, destinationLocation)
+                val sourceLocation = PTRMapWidgetPoiLocation(
+                    PTRIdentifier(siteId, isExternal = true),
+                    PTRIdentifier(sourcePoiId, isExternal = true)
+                )
+                val destinationLocation = PTRMapWidgetPoiLocation(
+                    PTRIdentifier(siteId, isExternal = true),
+                    PTRIdentifier(destinationPoiId, isExternal = true)
+                )
+                PTRMapWidgetAction.displayRoute(sourceLocation, destinationLocation)
             }
 
-            PTRMapWidgetCommandType.MARK_MY_CAR_SITE -> {
+            "markMyCarForSite" -> {
                 val siteId = args.getString(0).orEmpty()
-                val location = PTRMapWidgetSiteLocation(siteId, isExternal = true)
-                PTRMapWidgetMarkMyCarAction(location, shouldShowPopup = args.getBoolean(1))
+                val location = PTRMapWidgetSiteLocation(PTRIdentifier(siteId, isExternal = true))
+                PTRMapWidgetAction.markMyCar(location, args.getBoolean(1))
             }
 
-            PTRMapWidgetCommandType.MARK_MY_CAR_LEVEL -> {
+            "markMyCarForLevel" -> {
                 val siteId = args.getString(0).orEmpty()
+                val buildingId = args.getString(1).orEmpty()
                 val location = PTRMapWidgetLevelLocation(
-                    siteId,
-                    args.getString(1).orEmpty(),
-                    args.getInt(2),
-                    isExternalIdentifier = true
+                    PTRIdentifier(siteId, isExternal = true),
+                    PTRIdentifier(buildingId, isExternal = true),
+                    args.getInt(2)
                 )
                 PTRMapWidgetMarkMyCarAction(location, shouldShowPopup = args.getBoolean(3))
             }
 
-            PTRMapWidgetCommandType.SHOW_MY_CAR_SITE -> {
+            "showMyCarForSite" -> {
                 val siteId = args.getString(0).orEmpty()
-                val location = PTRMapWidgetSiteLocation(siteId, isExternal = true)
-                PTRMapWidgetShowMyCarAction(location, shouldShowPopup = args.getBoolean(1))
+                val location = PTRMapWidgetSiteLocation(PTRIdentifier(siteId, isExternal = true))
+                PTRMapWidgetAction.showMyCar(location, shouldShowPopup = args.getBoolean(1))
             }
 
-            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
-
-                // Next parameter is focus type (site, building, level, poi)
-                val focusType = args.getString(4).orEmpty()
+            PTRMapWidgetActionType.FOCUS_COORDINATE -> {
+                val siteId = args.getString(0).orEmpty()
+                val latitude = args.getDouble(1)
+                val longitude = args.getDouble(2)
+                val levelIndex = if (args.size() > 3) args.getInt(3) else -1
+                val location = PTRMapWidgetCoordinateLocation(
+                    siteId = PTRIdentifier(siteId, isExternal = true),
+                    buildingId = null,
+                    levelIndex = if (levelIndex >= 0) levelIndex else null,
+                    latitude = latitude,
+                    longitude = longitude
+                )
+                PTRMapWidgetAction.focusMap(location)
+            }
 
-                // Create focus action based on type
-                val location = when (focusType) {
-                    PTRMapWidgetCommandType.SITE -> {
-                        val siteId = args.getString(5).orEmpty()
-                        PTRMapWidgetSiteLocation(siteId, isExternal = 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, isExternal = true)
-                    }
+            PTRMapWidgetActionType.HIGHLIGHT_CATEGORY -> {
+                val siteId = args.getString(0).orEmpty()
+                val categoryIds = mutableListOf<String>()
+                val arr = args.getArray(1)
+                if (arr != null) {
+                    for (i in 0 until arr.size()) categoryIds.add(arr.getString(i).orEmpty())
                 }
-                PTRMapWidgetFocusAction(location)
+                val site = PTRMapWidgetSiteLocation(PTRIdentifier(siteId, isExternal = true))
+                PTRMapWidgetAction.highlightCategory(site, categoryIds.firstOrNull() ?: "")
             }
 
             else -> return
@@ -420,64 +398,57 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
     }
 
     private fun mapWidgetDidEndLoading(
-        @PTRMapWidgetCommandType command: String,
+        @PTRMapWidgetActionType command: String,
         vararg args: Any
     ) {
         val event: WritableMap = WritableNativeMap()
         event.putString("command", command)
         when (command) {
-            PTRMapWidgetCommandType.SITE -> {
+            "site" -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("error", args[1] as String)
             }
 
-            PTRMapWidgetCommandType.BUILDING -> {
+            "building" -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("buildingExternalIdentifier", args[1] as String)
                 event.putString("error", args[2] as String)
             }
 
-            PTRMapWidgetCommandType.LEVEL -> {
+            "level" -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("buildingExternalIdentifier", args[1] as String)
                 event.putInt("levelIndex", (args[2] as Number).toInt())
                 event.putString("error", args[3] as String)
             }
 
-            PTRMapWidgetCommandType.POI -> {
+            "poi" -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("poiExternalIdentifier", args[1] as String)
                 event.putString("error", args[2] as String)
             }
 
-            PTRMapWidgetCommandType.PATH -> {
+            PTRMapWidgetActionType.START_WAYFINDING -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("poiExternalIdentifier", args[1] as String)
                 event.putString("error", args[2] as String)
             }
 
-            PTRMapWidgetCommandType.STATIC_PATH -> {
+            PTRMapWidgetActionType.DISPLAY_ROUTE -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("fromPoiExternalIdentifier", args[1] as String)
                 event.putString("toPoiExternalIdentifier", args[2] as String)
                 event.putString("error", args[3] as String)
             }
 
-            PTRMapWidgetCommandType.STATIC_WAYFINDING -> {
-                event.putString("siteExternalIdentifier", args[0] as String)
-                event.putString("sourcePoiExternalIdentifier", args[1] as String)
-                event.putString("destinationPoiExternalIdentifier", args[2] as String)
-                event.putString("error", args[3] as String)
-            }
-
-            PTRMapWidgetCommandType.MARK_MY_CAR_SITE -> {
+            "markMyCarForSite" -> {
                 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 -> {
+            "markMyCarForLevel" -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putString("buildingExternalIdentifier", args[1] as String)
                 event.putInt("levelIndex", (args[2] as Number).toInt())
@@ -486,50 +457,13 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 event.putString("error", args[5] as String)
             }
 
-            PTRMapWidgetCommandType.SHOW_MY_CAR_SITE -> {
+            "showMyCarForSite" -> {
                 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
             }
@@ -555,185 +489,14 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
     }
 
     override fun getExportedCustomBubblingEventTypeConstants(): Map<String, Any> {
+        fun bubbled(name: String) = mapOf("phasedRegistrationNames" to mapOf("bubbled" to name))
         return mapOf(
-            "onMapWidgetDidEndLoading" to mapOf(
-                "phasedRegistrationNames" to mapOf(
-                    "bubbled" to "onMapWidgetDidEndLoading"
-                )
-            ),
-            "onWayfindingEvent" to mapOf(
-                "phasedRegistrationNames" to mapOf(
-                    "bubbled" to "onWayfindingEvent"
-                )
-            )
+            "onMapWidgetDidEndLoading" to bubbled("onMapWidgetDidEndLoading"),
+            "onWayfindingEvent" to bubbled("onWayfindingEvent")
         )
     }
 
 
-    private fun showStaticPath(
-        ptrMapWidgetFragment: PTRMapWidgetFragment,
-        site: String,
-        fromPoi: String,
-        toPoi: String
-    ) {
-        val siteObject = getSite(site) ?: run {
-            mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.STATIC_PATH,
-                site,
-                fromPoi,
-                toPoi,
-                "Site not found"
-            )
-            return
-        }
-        if (!waitForSiteData(siteObject)) {
-            mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.STATIC_PATH,
-                site,
-                fromPoi,
-                toPoi,
-                "Site data not found"
-            )
-            return
-        }
-        val source = Pointr.getPointr()?.poiManager?.getPoiByExternalIdentifier(siteObject, fromPoi)
-            ?: run {
-                mapWidgetDidEndLoading(
-                    PTRMapWidgetCommandType.STATIC_PATH,
-                    site,
-                    fromPoi,
-                    toPoi,
-                    "Source POI not found"
-                )
-                return
-            }
-        val target =
-            Pointr.getPointr()?.poiManager?.getPoiByExternalIdentifier(siteObject, toPoi) ?: run {
-                mapWidgetDidEndLoading(
-                    PTRMapWidgetCommandType.STATIC_PATH,
-                    site,
-                    fromPoi,
-                    toPoi,
-                    "Target POI not found"
-                )
-                return
-            }
-        if (!waitForPathManager(siteObject)) {
-            mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.STATIC_PATH,
-                site,
-                fromPoi,
-                toPoi,
-                "Path manager not ready"
-            )
-            return
-        }
-        val wayfindingManager = Pointr.getPointr()?.wayfindingManager ?: run {
-            mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.STATIC_PATH,
-                site,
-                fromPoi,
-                toPoi,
-                "Path manager not found"
-            )
-            return
-        }
-        val route = wayfindingManager.calculateRoute(source, listOf(target)) ?: run {
-            mapWidgetDidEndLoading(
-                PTRMapWidgetCommandType.STATIC_PATH,
-                site,
-                fromPoi,
-                toPoi,
-                "Path not found"
-            )
-            return
-        }
-        val layer = PTRMapSymbolLayer(
-            LAYER_STATIC_PATH
-        )
-        ptrMapWidgetFragment.mapFragment?.addLayer(layer) { isSuccess, message ->
-            if (!isSuccess) {
-                mapWidgetDidEndLoading(
-                    PTRMapWidgetCommandType.STATIC_PATH,
-                    site,
-                    fromPoi,
-                    toPoi,
-                    "Failed to add static path layer: $message"
-                )
-                return@addLayer
-            }
-            Log.i(name, "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
-                }
-                Log.i(name, "POI features added successfully")
-                ptrMapWidgetFragment.mapFragment?.currentRoute = route
-                mapWidgetDidEndLoading(
-                    PTRMapWidgetCommandType.STATIC_PATH,
-                    site,
-                    fromPoi,
-                    toPoi,
-                    ""
-                )
-            }
-        }
-    }
-
-    // region Show path
-
-    private fun waitForPathManager(theSite: Site): Boolean {
-        val wayfindingManager = Pointr.getPointr()?.wayfindingManager ?: return false
-        val semaphore = Semaphore(0)
-        val listener = object : WayfindingManager.Listener {
-            override fun onWayfindingManagerReadyForSite(site: Site) {
-                if (site != theSite) return
-                semaphore.release()
-            }
-        }
-        wayfindingManager.addListener(listener)
-        if (!wayfindingManager.isReadyForSite(theSite)) {
-            semaphore.tryAcquire(15, java.util.concurrent.TimeUnit.SECONDS)
-        }
-        wayfindingManager.removeListener(listener)
-        return wayfindingManager.isReadyForSite(theSite)
-    }
-
-    private fun waitForSiteData(theSite: Site): Boolean {
-        val dataManager = Pointr.getPointr()?.dataManager ?: return false
-        val semaphore = Semaphore(0)
-        val listener = object : DataManager.Listener {
-            override fun onDataManagerCompleteAllForSite(
-                site: Site,
-                isSuccessful: Boolean,
-                isOnlineData: Boolean,
-                errors: List<ErrorMessage?>?
-            ) {
-                if (site != theSite) return
-                if (!isOnlineData) return
-                semaphore.release()
-            }
-        }
-        dataManager.addListener(listener)
-        if (Pointr.getPointr()?.poiManager?.hasContentForSite(theSite) != true) {
-            dataManager.loadDataForSite(theSite)
-            semaphore.tryAcquire(15, java.util.concurrent.TimeUnit.SECONDS)
-        }
-        dataManager.removeListener(listener)
-        return Pointr.getPointr()?.poiManager?.hasContentForSite(theSite) == true
-    }
-
     private fun getSite(siteExternalId: String): Site? {
         val siteManager = Pointr.getPointr()?.siteManager ?: return null
         val semaphore = Semaphore(0)
@@ -750,8 +513,6 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         return siteManager.getSiteByExternalIdentifier(siteExternalId)
     }
 
-    // endregion
-
     private fun waitForPointrToRun(): Boolean {
         Log.e(
             "PTRMapWidgetManager",
@@ -816,12 +577,8 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         Log.e(name, "Map failed to load: $ptrError")
     }
 
-    override fun onMarkMyCarDetailsEvent(
-        markMyCarSheet: MarkMyCarBottomSheet,
-        markMyCarDetailsEvent: MarkMyCarDetailsEvent
-    ) {
-        super.onMarkMyCarDetailsEvent(markMyCarSheet, markMyCarDetailsEvent)
-        Log.i(name, "Mark my car details event: $markMyCarDetailsEvent")
+    override fun onDidEndLoading(error: String?) {
+        Log.i(name, "Map widget finished loading, error=$error")
     }
 
     private val frameCallback = object : Choreographer.FrameCallback {
@@ -837,9 +594,9 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 frameLayout.bottom
             )
             frameLayout.viewTreeObserver.dispatchOnGlobalLayout()
-            // Execute a declarative command prop once the view has non-zero dimensions.
-            if (!commandTriggered && frameLayout.width > 0 && frameLayout.height > 0) {
-                commandTriggered = true
+            // Execute a declarative action prop once the view has non-zero dimensions.
+            if (!actionTriggered && frameLayout.width > 0 && frameLayout.height > 0) {
+                actionTriggered = true
                 executePendingCommandIfNeeded()
             }
             Choreographer.getInstance().postFrameCallback(this)
@@ -867,7 +624,6 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
 
     companion object {
         const val REACT_CLASS = "PTRMapWidget"
-        const val LAYER_STATIC_PATH = "sym-static-path"
     }
 
 }