react-native-pointr 8.16.0 → 9.1.0

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

@@ -2,7 +2,6 @@ package com.pointr
 
 import android.Manifest
 import android.annotation.SuppressLint
-import android.content.Intent
 import android.os.Build
 import android.os.Parcel
 import android.os.Parcelable
@@ -15,20 +14,19 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.pointrlabs.core.management.Pointr
-import com.pointrlabs.core.management.PositionManager
+import com.pointrlabs.core.management.PositioningManager
 import com.pointrlabs.core.management.interfaces.PointrListener
 import com.pointrlabs.core.management.models.Building
-import com.pointrlabs.core.management.models.Level
 import com.pointrlabs.core.management.models.PTRParams
-import com.pointrlabs.core.management.models.PointrEnvironment
 import com.pointrlabs.core.management.models.Site
-import com.pointrlabs.core.map.models.PTRError
-import com.pointrlabs.core.map.models.events_listeners.MapEventsListener
-import com.pointrlabs.core.map.views.PTRMapFragment
-import com.pointrlabs.core.map.views.helper_views.PTRDialog
 import com.pointrlabs.core.nativecore.wrappers.Plog
-import com.pointrlabs.core.positioning.model.CalculatedLocation
+import com.pointrlabs.core.positioning.model.CalculatedPosition
 import com.pointrlabs.core.positioning.model.PositioningTypes
+import com.pointrlabs.core.util.models.error.PTRError
+import com.pointrlabs.ui.map.models.events_listeners.MapEventsListener
+import com.pointrlabs.ui.map.viewmodels.PTRMapWidgetConfiguration
+import com.pointrlabs.ui.map.views.PTRMapFragment
+import com.pointrlabs.ui.map.views.helper_views.PTRDialog
 import org.json.JSONObject
 import kotlin.random.Random
 import kotlin.reflect.KMutableProperty1
@@ -37,21 +35,15 @@ import kotlin.reflect.KMutableProperty1
 class PointrModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
-    private val positionManagerListener: PositionManager.Listener
+    private val positionManagerListener: PositioningManager.Listener
     private var listenerCount = 0
 
     init {
-        positionManagerListener = object : PositionManager.Listener {
-            override fun onPositionManagerCalculatedLocation(p0: CalculatedLocation?) {
-                val calculatedLocation = p0 ?: return
-                val params = applyParamsForCalculatedLocation(calculatedLocation)
+        positionManagerListener = object : PositioningManager.Listener {
+            override fun onPositioningManagerCalculatedPosition(position: CalculatedPosition) {
+                val params = applyParamsForCalculatedLocation(position)
                 sendEventToJs(reactContext, OnPositionManagerCalculatedLocation, params)
             }
-
-            override fun onPositionManagerDetectedPositionLevelChange(p0: Level) {}
-            override fun onPositionManagerPositionIsFading() {}
-            override fun onPositionManagerPositionIsLost() {}
-            override fun onPositionManagerPositioningServiceStateChangedTo(p0: PositioningTypes.PositioningServiceState?) {}
         }
         setPointrListeners()
     }
@@ -116,18 +108,16 @@ class PointrModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun initialize(
+        clientId: String,
         licenceKey: String,
         baseUrl: String,
-        clientId: String,
-        env: String,
         logLevel: Int
     ) {
         initialize(
             reactApplicationContext,
             clientId,
-            baseUrl,
             licenceKey,
-            env,
+            baseUrl,
             logLevel
         )
     }
@@ -167,134 +157,10 @@ class PointrModule(reactContext: ReactApplicationContext) :
         val pointr = Pointr.getPointr() ?: return callback.invoke(null)
         if (pointr.state != Pointr.State.RUNNING) return callback.invoke(null)
         val calculatedLocation =
-            pointr.positionManager?.currentCalculatedLocation ?: return callback.invoke(null)
+            pointr.positioningManager?.currentCalculatedPosition ?: return callback.invoke(null)
         callback.invoke(applyParamsForCalculatedLocation(calculatedLocation))
     }
 
-    @ReactMethod
-    fun showSite(siteExternalId: String, animationType: Int, callback: Callback) {
-        val activity = currentActivity ?: run {
-            callback.invoke("Could not get current activity")
-            return
-        }
-
-        val intent = Intent(activity, PointrMapWidgetActivity::class.java)
-        intent.putExtra(mapEventsListenerKey, CustomMapEventsListener(reactApplicationContext))
-        intent.action = PointrMapWidgetActivity.SHOW_SITE
-        intent.putExtra(PointrMapWidgetActivity.siteExternalIdentifierKey, siteExternalId)
-        intent.putExtra(PointrMapWidgetActivity.animationTypeKey, animationType)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        PointrMapWidgetActivity.callback = callback
-        activity.startActivity(intent)
-    }
-
-    @ReactMethod
-    fun showBuilding(
-        siteExternalId: String,
-        buildingExternalId: String,
-        animationType: Int,
-        callback: Callback
-    ) {
-        val activityContext =
-            currentActivity ?: return callback.invoke("Could not get current activity")
-        val intent = Intent(activityContext, PointrMapWidgetActivity::class.java)
-        intent.putExtra(mapEventsListenerKey, CustomMapEventsListener(reactApplicationContext))
-        intent.action = PointrMapWidgetActivity.SHOW_BUILDING
-        intent.putExtra(PointrMapWidgetActivity.siteExternalIdentifierKey, siteExternalId)
-        intent.putExtra(PointrMapWidgetActivity.buildingExternalIdentifierKey, buildingExternalId)
-        intent.putExtra(PointrMapWidgetActivity.animationTypeKey, animationType)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        PointrMapWidgetActivity.callback = callback
-        activityContext.startActivity(intent)
-    }
-
-    @ReactMethod
-    fun showLevel(
-        siteExternalId: String,
-        buildingExternalId: String,
-        levelIndex: Int,
-        animationType: Int,
-        callback: Callback
-    ) {
-        val activityContext =
-            currentActivity ?: return callback.invoke("Could not get current activity")
-        val intent = Intent(activityContext, PointrMapWidgetActivity::class.java)
-        intent.putExtra(mapEventsListenerKey, CustomMapEventsListener(reactApplicationContext))
-        intent.action = PointrMapWidgetActivity.SHOW_LEVEL
-        intent.putExtra(PointrMapWidgetActivity.siteExternalIdentifierKey, siteExternalId)
-        intent.putExtra(PointrMapWidgetActivity.buildingExternalIdentifierKey, buildingExternalId)
-        intent.putExtra(PointrMapWidgetActivity.levelIndexKey, levelIndex)
-        intent.putExtra(PointrMapWidgetActivity.animationTypeKey, animationType)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        PointrMapWidgetActivity.callback = callback
-        activityContext.startActivity(intent)
-    }
-
-    @ReactMethod
-    fun showPoiDetails(
-        siteExternalId: String,
-        poiExternalId: String,
-        animationType: Int,
-        callback: Callback
-    ) {
-        val activityContext =
-            currentActivity ?: return callback.invoke("Could not get current activity")
-        val intent = Intent(activityContext, PointrMapWidgetActivity::class.java)
-        intent.putExtra(mapEventsListenerKey, CustomMapEventsListener(reactApplicationContext))
-        intent.action = PointrMapWidgetActivity.SHOW_POI_DETAILS
-        intent.putExtra(PointrMapWidgetActivity.siteExternalIdentifierKey, siteExternalId)
-        intent.putExtra(PointrMapWidgetActivity.poiExternalIdentifierKey, poiExternalId)
-        intent.putExtra(PointrMapWidgetActivity.animationTypeKey, animationType)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        PointrMapWidgetActivity.callback = callback
-        activityContext.startActivity(intent)
-    }
-
-    @ReactMethod
-    fun showPathFindingToPoi(
-        siteExternalId: String,
-        poiExternalId: String,
-        animationType: Int,
-        callback: Callback
-    ) {
-        val activityContext =
-            currentActivity ?: return callback.invoke("Could not get current activity")
-        val intent = Intent(activityContext, PointrMapWidgetActivity::class.java)
-        intent.putExtra(mapEventsListenerKey, CustomMapEventsListener(reactApplicationContext))
-        intent.action = PointrMapWidgetActivity.SHOW_PATHFINDING_TO_POI
-        intent.putExtra(PointrMapWidgetActivity.siteExternalIdentifierKey, siteExternalId)
-        intent.putExtra(PointrMapWidgetActivity.poiExternalIdentifierKey, poiExternalId)
-        intent.putExtra(PointrMapWidgetActivity.animationTypeKey, animationType)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        PointrMapWidgetActivity.callback = callback
-        activityContext.startActivity(intent)
-    }
-
-    @ReactMethod
-    fun showPathFindingBetweenPOIs(
-        siteExternalId: String,
-        sourcePoiExternalId: String,
-        destinationPoiExternalId: String,
-        animationType: Int,
-        callback: Callback
-    ) {
-        val activityContext =
-            currentActivity ?: return callback.invoke("Could not get current activity")
-        val intent = Intent(activityContext, PointrMapWidgetActivity::class.java)
-        intent.putExtra(mapEventsListenerKey, CustomMapEventsListener(reactApplicationContext))
-        intent.action = PointrMapWidgetActivity.SHOW_PATHFINDING_BETWEEN_POIS
-        intent.putExtra(PointrMapWidgetActivity.siteExternalIdentifierKey, siteExternalId)
-        intent.putExtra(PointrMapWidgetActivity.sourcePoiExternalIdentifierKey, sourcePoiExternalId)
-        intent.putExtra(
-            PointrMapWidgetActivity.destinationPoiExternalIdentifierKey,
-            destinationPoiExternalId
-        )
-        intent.putExtra(PointrMapWidgetActivity.animationTypeKey, animationType)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        PointrMapWidgetActivity.callback = callback
-        activityContext.startActivity(intent)
-    }
-
     @ReactMethod
     fun setPointrMapWidgetConfiguration(configurationString: String) {
         try {
@@ -307,7 +173,7 @@ class PointrModule(reactContext: ReactApplicationContext) :
 
     companion object {
         const val NAME = "PTRNativePointrLibrary"
-
+        val mapWidgetConfiguration = PTRMapWidgetConfiguration.defaultConfiguration()
         const val siteInternalIdentifierKey = "siteInternalIdentifier"
         const val siteExternalIdentifierKey = "siteExternalIdentifier"
         const val buildingInternalIdentifierKey = "buildingInternalIdentifier"
@@ -394,9 +260,9 @@ class PointrModule(reactContext: ReactApplicationContext) :
         // region [com.pointrlabs.core.map.models.events_listeners.CustomMapEventsListener]
         override fun mapDidReceiveTapOnBuilding(mapFragment: PTRMapFragment, building: Building) {
             val params: WritableMap = Arguments.createMap()
-            params.putInt(INTERNAL_ID, building.internalIdentifier)
+            params.putString(INTERNAL_ID, building.identifier)
             params.putString(EXTERNAL_ID, building.externalIdentifier)
-            params.putString(TITLE, building.title)
+            params.putString(TITLE, building.name)
             reactContext?.let {
                 sendEventToJs(it, OnBuildingClicked, params)
             }
@@ -404,9 +270,9 @@ class PointrModule(reactContext: ReactApplicationContext) :
 
         override fun mapDidReceiveTapOnSite(mapFragment: PTRMapFragment, site: Site) {
             val params: WritableMap = Arguments.createMap()
-            params.putInt(INTERNAL_ID, site.internalIdentifier)
+            params.putString(INTERNAL_ID, site.identifier)
             params.putString(EXTERNAL_ID, site.externalIdentifier)
-            params.putString(TITLE, site.title)
+            params.putString(TITLE, site.name)
             reactContext?.let {
                 sendEventToJs(it, OnSiteClicked, params)
             }
@@ -421,11 +287,11 @@ class PointrModule(reactContext: ReactApplicationContext) :
             ptrMapWidgetFragment.parentFragmentManager.beginTransaction()
                 .remove(ptrMapWidgetFragment).commit()
             val ptrDialogModel = PTRDialog.PtrDialogModel(
-                iconDrawableResId = com.pointrlabs.core.R.drawable.error_generic,
-                bigTextString = activity.getString(com.pointrlabs.core.R.string.ptr_error_title_map_loading_generic_error),
-                smallTextString = activity.getString(com.pointrlabs.core.R.string.no_internet),
+                iconDrawableResId = com.pointrlabs.ui.R.drawable.error_generic,
+                bigTextString = activity.getString(com.pointrlabs.ui.R.string.ptr_error_title_map_loading_generic_error),
+                smallTextString = activity.getString(com.pointrlabs.ui.R.string.no_internet),
                 primaryButton = PTRDialog.PtrDialogButtonModel(
-                    activity.getString(com.pointrlabs.core.R.string.ok)
+                    activity.getString(com.pointrlabs.ui.R.string.ok)
                 ) { dialog, _ ->
                     dialog.dismiss()
                     // finish the activity after we are done with the dialog
@@ -442,18 +308,18 @@ class PointrModule(reactContext: ReactApplicationContext) :
         // endregion [com.pointrlabs.core.map.models.events_listeners.CustomMapEventsListener]
     }
 
-    private fun applyParamsForCalculatedLocation(calculatedLocation: CalculatedLocation): WritableMap {
+    private fun applyParamsForCalculatedLocation(calculatedLocation: CalculatedPosition): WritableMap {
         val params: WritableMap = Arguments.createMap()
         val site = calculatedLocation.site
         val building = calculatedLocation.building
         val level = calculatedLocation.level
-        val loc = calculatedLocation.location
+        val loc = calculatedLocation.position
         site?.let {
-            params.putInt(siteInternalIdentifierKey, it.internalIdentifier)
+            params.putString(siteInternalIdentifierKey, it.identifier)
             params.putString(siteExternalIdentifierKey, it.externalIdentifier)
         }
         building?.let {
-            params.putInt(buildingInternalIdentifierKey, it.internalIdentifier)
+            params.putString(buildingInternalIdentifierKey, it.identifier)
             params.putString(buildingExternalIdentifierKey, it.externalIdentifier)
         }
         level?.let {
@@ -466,7 +332,7 @@ class PointrModule(reactContext: ReactApplicationContext) :
         if (calculatedLocation.accuracy != PositioningTypes.INVALID_FLOAT) {
             params.putDouble(accuracyKey, calculatedLocation.accuracy)
         }
-        if (calculatedLocation.headingAccuracyClass == CalculatedLocation.HeadingAccuracyClass.HIGH) {
+        if (calculatedLocation.headingAccuracyClass == CalculatedPosition.HeadingAccuracyClass.HIGH) {
             params.putDouble(headingKey, calculatedLocation.heading)
         }
         return params
@@ -475,18 +341,11 @@ class PointrModule(reactContext: ReactApplicationContext) :
     fun initialize(
         reactContext: ReactApplicationContext,
         clientId: String,
-        baseUrl: String,
         licenceKey: String,
-        env: String,
+        baseUrl: String,
         logLevel: Int
     ) {
         val ptrParams = PTRParams(clientId, licenceKey, baseUrl)
-        try {
-            val environment = PointrEnvironment.valueOf(env)
-            ptrParams.environment = environment
-        } catch (ex: IllegalArgumentException) {
-            Log.e(name, "Could not set environment of PTRParams for env: $env")
-        }
         try {
             val ptrLogLevel = Plog.LogLevel.entries[logLevel]
             ptrParams.logLevel = ptrLogLevel
@@ -513,31 +372,31 @@ class PointrModule(reactContext: ReactApplicationContext) :
     fun removePointrListeners() {
         val pointr = Pointr.getPointr() ?: return
         if (pointr.state != Pointr.State.RUNNING) return
-        pointr.positionManager?.removeListener(positionManagerListener)
+        pointr.positioningManager?.removeListener(positionManagerListener)
     }
 
     private fun setPointrListeners() {
         val pointr = Pointr.getPointr() ?: return
         if (pointr.state != Pointr.State.RUNNING) return
-        pointr.positionManager?.addListener(positionManagerListener)
+        pointr.positioningManager?.addListener(positionManagerListener)
         if (shouldRequestPermissionsAtStartup) {
             requestPermissions()
         } else {
-            pointr.permissionManager?.shouldRequestLocationPermissionForWhileInUse = false
-            pointr.permissionManager?.shouldRequestBluetoothPermission = false
-            pointr.permissionManager?.shouldRequestLocationPermissionForAlways = false
+            pointr.permissionManager.shouldRequestLocationPermissionForWhileInUse = false
+            pointr.permissionManager.shouldRequestBluetoothPermission = false
+            pointr.permissionManager.shouldRequestLocationPermissionForAlways = false
         }
     }
 
     fun setPointrMapWidgetConfiguration(jsonObject: JSONObject) {
-        PointrMapWidgetActivity.mapWidgetConfiguration::class.members.forEach { kCallable ->
+        mapWidgetConfiguration::class.members.forEach { kCallable ->
             if (kCallable !is KMutableProperty1<*, *>) return@forEach
             if (!jsonObject.has(kCallable.name)) return@forEach
             try {
                 val value = if (kCallable.name == "isBuildingLevelSelectorEnabled")
                     jsonObject.getBoolean("isLevelSelectorEnabled")
                 else jsonObject.getBoolean(kCallable.name)
-                kCallable.setter.call(PointrMapWidgetActivity.mapWidgetConfiguration, value)
+                kCallable.setter.call(mapWidgetConfiguration, value)
             } catch (_: Exception) {
             }
         }

package/ios/PTRMapWidgetContainerView.swift

@@ -0,0 +1,247 @@
+import UIKit
+import PointrKit
+
+@objc class PTRMapWidgetContainerView: UIView, PTRSiteManagerDelegate, PTRDataManagerDelegate, PTRWayfindingManagerDelegate {
+    
+    @objc var onMapWidgetDidEndLoading: RCTBubblingEventBlock?
+    
+    private(set) var mapWidget: PTRMapWidgetViewController?
+    var semaphore: DispatchSemaphore?
+    var site: PTRSite?
+    
+    private let kLayerStaticPath = "static-path"
+    
+    @objc func ptrMapWidgetDidEndLoading(withParameters parameters: [String: Any]) {
+        onMapWidgetDidEndLoading?(parameters)
+    }
+    
+    @objc func getMapWidget(_ action: PTRMapWidgetAction) -> PTRMapWidgetViewController {
+        if waitForPointrState() != .running {
+            print("Pointr is not running")
+        }
+        
+        print("initializing map widget")
+        mapWidget = PTRMapWidgetViewController(action: action, configuration: PTRNativeLibrary.mapWidgetConfiguration)
+        return mapWidget!
+    }
+    
+    @objc func present(_ mapWidget: PTRMapWidgetViewController) {
+        addSubview(mapWidget.view)
+        mapWidget.view.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            mapWidget.view.leadingAnchor.constraint(equalTo: self.leadingAnchor),
+            mapWidget.view.trailingAnchor.constraint(equalTo: self.trailingAnchor),
+            mapWidget.view.topAnchor.constraint(equalTo: self.topAnchor),
+            mapWidget.view.bottomAnchor.constraint(equalTo: self.bottomAnchor)
+        ])
+    }
+    
+    @objc func showStaticPath(_ siteExternalIdentifier: String,
+                              fromPoiExternalIdentifier: String,
+                              toPoiExternalIdentifier: String) {
+        waitForPointrState()
+        
+        var ptrCommand: [String: Any] = [
+            "command": "staticPath",
+            "siteExternalIdentifier": siteExternalIdentifier,
+            "fromPoiExternalIdentifier": fromPoiExternalIdentifier,
+            "toPoiExternalIdentifier": toPoiExternalIdentifier
+        ]
+        
+        guard let site = getSite(siteExternalIdentifier) else {
+            ptrCommand["error"] = "Site not found"
+            ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+            print("no site found")
+            return
+        }
+        
+        guard let fromPoi = getPoi(site, poiExternalIdentifier: fromPoiExternalIdentifier) else {
+            ptrCommand["error"] = "Source poi not found"
+            ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+            print("Source poi not found")
+            return
+        }
+        
+        guard let toPoi = getPoi(site, poiExternalIdentifier: toPoiExternalIdentifier) else {
+            ptrCommand["error"] = "Target poi not found"
+            ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+            print("Destination poi not found")
+            return
+        }
+        
+        waitForPath(site)
+        
+        guard let pathManager = Pointr.shared.wayfindingManager else {
+            ptrCommand["error"] = "Path manager not found"
+            ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+            print("Path manager not found")
+            return
+        }
+        
+        guard let route = pathManager.calculateRoute(fromPosition: fromPoi, toNearestPositionIn: [toPoi]) else {
+            ptrCommand["error"] = "Path not found"
+            ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+            print("Path not found")
+            return
+        }
+        
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self = self else { return }
+            
+            let location: PTRMapWidgetLocation
+            if let level = fromPoi.position.level {
+                location = PTRMapWidgetLevelLocation(
+                    siteIdentifier: site.identifier,
+                    buildingIdentifier: level.building.identifier,
+                    levelIndex: Int(level.index),
+                    isExternalIdentifiers: false
+                )
+            } else {
+                location = PTRMapWidgetSiteLocation(
+                    siteIdentifier: site.identifier,
+                    isExternalIdentifiers: false
+                )
+            }
+            let action = PTRMapWidgetMapFocusAction(location: location)
+            let mapWidget = self.getMapWidget(action)
+            action.completion = { [weak self, weak mapWidget] error in
+                guard let self = self, let mapWidget = mapWidget else {
+                    ptrCommand["error"] = "Lost reference to PTRMapWidgetContainerView and/or PTRMapWidgetViewController"
+                    self?.ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+                    print("Error showing level: Lost reference to PTRMapWidgetContainerView and/or PTRMapWidgetViewController")
+                    return
+                }
+                if let error = error {
+                    ptrCommand["error"] = error.errorCode
+                    self.ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+                    print("Error showing level: \(error.errorCode ?? "")")
+                    return
+                }
+                self.setStaticPath(mapWidget.mapViewController, fromPoi: fromPoi, toPoi: toPoi, route: route)
+                ptrCommand["error"] = ""
+                self.ptrMapWidgetDidEndLoading(withParameters: ptrCommand)
+                print("ready")
+            }
+            self.present(mapWidget)
+        }
+        DispatchQueue.main.async(execute: workItem)
+    }
+    
+    func setStaticPath(_ map: PTRMapViewController, fromPoi: PTRPoi, toPoi: PTRPoi, route: PTRRoute) {
+        let layer = PTRMapSymbolLayer(identifier: kLayerStaticPath)
+        map.addLayer(layer)
+        map.addFeatures([fromPoi, toPoi], toLayer: layer.identifier)
+        map.currentRoute = route
+        map.zoomToCoordinate(fromPoi.position.coordinate)
+    }
+    
+    func waitForPath(_ site: PTRSite) {
+        print("waiting for path to be ready")
+        guard let pathManager = Pointr.shared.wayfindingManager else { return }
+        
+        self.site = site
+        self.semaphore = DispatchSemaphore(value: 0)
+        pathManager.addListener(self)
+        if !pathManager.isReady(for: site) {
+            let timeout = DispatchTime.now() + .seconds(5)
+            if semaphore?.wait(timeout: timeout) == .timedOut {
+                print("Timeout waiting for pathmanager")
+            }
+        }
+        pathManager.removeListener(self)
+    }
+    
+    func onWayfindingManagerReady(for site: PTRSite) {
+        guard site.internalIdentifier == self.site?.internalIdentifier else { return }
+        print("path became ready.")
+        semaphore?.signal()
+    }
+    
+    func getPoi(_ site: PTRSite, poiExternalIdentifier: String) -> PTRPoi? {
+        guard let poiManager = Pointr.shared.poiManager else { return nil }
+        
+        if !poiManager.hasContent(for: site) {
+            waitForPois(site)
+        }
+        
+        if let poi = poiManager.pois(for: site, withExternalIdentifier: poiExternalIdentifier) {
+            return poi
+        }
+        
+        return poiManager.pois(for: site, withIdentifier: poiExternalIdentifier)
+    }
+    
+    func waitForPois(_ site: PTRSite) {
+        print("waiting for data to be ready")
+        guard let dataManager = Pointr.shared.dataManager else { return }
+        
+        self.site = site
+        self.semaphore = DispatchSemaphore(value: 0)
+        dataManager.addListener(self)
+        dataManager.loadData(forSite: site.internalIdentifier)
+        
+        if !dataManager.isContentReady(forSite: site.internalIdentifier) {
+            let timeout = DispatchTime.now() + .seconds(5)
+            if semaphore?.wait(timeout: timeout) == .timedOut {
+                print("Timeout waiting for datamanager")
+            }
+        }
+        dataManager.removeListener(self)
+    }
+    
+    func onDataManagerCompleteAll(for site: PTRSite,
+                                  isSuccessful: Bool,
+                                  dataFromOnline isOnlineData: Bool,
+                                  errorMessages: [NSNumber : String]) {
+        guard isOnlineData else { return }
+        guard site.internalIdentifier == self.site?.internalIdentifier else { return }
+        
+        print("data became ready.")
+        semaphore?.signal()
+    }
+    
+    func getSite(_ siteExternalIdentifier: String) -> PTRSite? {
+        guard let siteManager = Pointr.shared.siteManager else { return nil }
+        
+        if siteManager.sites().count == 0 {
+            waitForSites()
+        }
+        
+        return siteManager.site(withExternalIdentifier: siteExternalIdentifier)
+    }
+    
+    func waitForSites() {
+        print("waiting for sites")
+        self.semaphore = DispatchSemaphore(value: 0)
+        Pointr.shared.siteManager?.addListener(self)
+        let timeout = DispatchTime.now() + .seconds(5)
+        if semaphore?.wait(timeout: timeout) == .timedOut {
+            print("Timeout waiting for configuration")
+        }
+        Pointr.shared.siteManager?.removeListener(self)
+    }
+    
+    func onSiteManagerDataChanged() {
+        print("sites became ready.")
+        semaphore?.signal()
+    }
+    
+    @discardableResult
+    func waitForPointrState() -> PointrState {
+        print("waiting for pointr to run")
+        let state1 = Pointr.shared.state
+        
+        if state1 == .running || state1.rawValue < PointrState.off.rawValue {
+            return Pointr.shared.state
+        }
+        
+        let semaphore = DispatchSemaphore(value: 0)
+        Pointr.shared.start(with: PTRNativeLibrary.params) { state in
+            if state == .running || state.rawValue < PointrState.off.rawValue {
+                semaphore.signal()
+            }
+        }
+        semaphore.wait()
+        return Pointr.shared.state
+    }
+}

package/ios/PTRMapWidgetManager-Bridging.m

@@ -0,0 +1,59 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTLog.h>
+//
+//  PTRMapWidgetManager-Bridging.m
+//  
+//  This file provides Objective-C bridge methods for PTRMapWidgetManager
+//
+
+// The PTRMapWidgetManager is now implemented directly in Objective-C
+// No bridging methods needed as RCT_EXPORT_METHOD is used directly
+
+@interface RCT_EXTERN_MODULE(PTRMapWidgetManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(onMapWidgetDidEndLoading, RCTBubblingEventBlock)
+
+RCT_EXTERN_METHOD(site:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier)
+RCT_EXTERN_METHOD(building:(nonnull NSNumber *)reactTag
+                  siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                    buildingExternalIdentifier:(NSString *)buildingExternalIdentifier)
+
+RCT_EXTERN_METHOD(level:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                    buildingExternalIdentifier:(NSString *)buildingExternalIdentifier
+                  levelIndex:(NSInteger)levelIndex)
+                  
+RCT_EXTERN_METHOD(poi:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                  poiExternalIdentifier:(NSString *)poiExternalIdentifier)
+
+RCT_EXTERN_METHOD(path:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                  toPoiExternalIdentifier:(NSString *)toPoiExternalIdentifier)
+
+RCT_EXTERN_METHOD(staticPath:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                    fromPoiExternalIdentifier:(NSString *)fromPoiExternalIdentifier
+                    toPoiExternalIdentifier:(NSString *)toPoiExternalIdentifier)
+
+RCT_EXTERN_METHOD(markMyCarForLevel:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                    buildingExternalIdentifier:(NSString *)buildingExternalIdentifier
+                    levelIndex:(NSInteger)levelIndex
+                  shouldShowPopup:(BOOL)shouldShowPopup
+                  animationType:(NSInteger)animationType)
+
+RCT_EXTERN_METHOD(markMyCarForSite:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                  shouldShowPopup:(BOOL)shouldShowPopup
+                  animationType:(NSInteger)animationType)
+
+RCT_EXTERN_METHOD(myCarForSite:(nonnull NSNumber *)reactTag
+                    siteExternalIdentifier:(NSString *)siteExternalIdentifier
+                  animationType:(NSInteger)animationType)
+@end
+
+// No additional methods are needed here as the PTRMapWidgetManager is implemented in Objective-C