react-native-pointr 9.2.0 → 9.3.1

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

@@ -0,0 +1,126 @@
+package com.pointr
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.pointrlabs.core.geojson.PTRFeature
+import com.pointrlabs.core.geometry.GeoMultiPoint
+import com.pointrlabs.core.geometry.GeoMultiPolygon
+import com.pointrlabs.core.geometry.GeoPoint
+import com.pointrlabs.core.geometry.GeoPolygon
+import com.pointrlabs.core.geometry.Geometry
+import com.pointrlabs.core.positioning.model.Position
+
+val Position.map
+    get() = Arguments.createMap().apply {
+        putDouble("lat", lat)
+        putDouble("lon", lon)
+        putBoolean("isValid", isValid())
+        putString("sid", siteIdentifier)
+        putString("bid", buildingIdentifier)
+        putInt("lvl", levelIndex)
+    }
+
+private fun getAttributes(attributes: Map<*, *>): ReadableMap {
+    return Arguments.createMap().apply {
+        attributes.forEach { (key, value) ->
+            when (value) {
+                is Long -> putLong(key.toString(), value)
+
+                is Int -> putInt(key.toString(), value)
+
+                is Boolean -> putBoolean(key.toString(), value)
+
+                is String -> putString(key.toString(), value)
+
+                is Double -> putDouble(key.toString(), value)
+
+                is List<*> -> {
+                    putArray(key.toString(), Arguments.createArray().apply {
+                        value.forEach { v ->
+                            when (v) {
+                                is Int -> pushInt(v)
+                                is Double -> pushDouble(v)
+                                is Long -> pushLong(v)
+                                is Boolean -> pushBoolean(v)
+                                is String -> pushString(v)
+                                else -> pushNull()
+                            }
+                        }
+                    })
+                }
+
+                is Map<*, *> -> putMap(key.toString(), getAttributes(value))
+            }
+        }
+    }
+}
+
+val PTRFeature.map
+    get() = Arguments.createMap().apply {
+        putString("identifier", identifier)
+        putString("externalIdentifier", externalIdentifier)
+        putString("typeCode", typeCode)
+        putMap("geometry", geometry.map)
+        putMap("attributes", getAttributes(attributes))
+        putString("name", name)
+        putMap("position", position.map)
+    }
+
+val GeoPoint.map
+    get() = Arguments.createMap().apply {
+        putString("type", type.name)
+        putDouble("lat", lat)
+        putDouble("lon", lon)
+    }
+
+val GeoPolygon.map
+    get() = Arguments.createMap().apply {
+        putString("type", type.name)
+        putArray("outer", Arguments.createArray().apply {
+            outer.forEach { point ->
+                pushMap(point.map)
+            }
+        })
+        if (inners.isNotEmpty()) {
+            putArray("inners", Arguments.createArray().apply {
+                inners.forEach { inner ->
+                    Arguments.createArray().apply {
+                        inner.forEach { point ->
+                            pushMap(point.map)
+                        }
+                    }
+                }
+            })
+        }
+    }
+
+val GeoMultiPoint.map
+    get() = Arguments.createMap().apply {
+        putString("type", type.name)
+        putArray("points", Arguments.createArray().apply {
+            points.forEach { point ->
+                pushMap(point.map)
+            }
+        })
+    }
+
+val GeoMultiPolygon.map
+    get() = Arguments.createMap().apply {
+        putString("type", type.name)
+        putArray("polygons", Arguments.createArray().apply {
+            polygons.forEach { polygon ->
+                pushMap(polygon.map)
+            }
+        })
+    }
+
+val Geometry.map
+    get() = when (this) {
+        is GeoPoint -> this.map
+        is GeoPolygon -> this.map
+        is GeoMultiPoint -> this.map
+        is GeoMultiPolygon -> this.map
+        else -> Arguments.createMap().apply {
+            putString("type", type.name)
+        }
+    }

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

@@ -2,7 +2,7 @@ package com.pointr
 
 import androidx.annotation.StringDef
 
-@StringDef(value = [PTRMapWidgetCommandType.SITE, PTRMapWidgetCommandType.BUILDING, PTRMapWidgetCommandType.LEVEL, PTRMapWidgetCommandType.POI, PTRMapWidgetCommandType.PATH, PTRMapWidgetCommandType.STATIC_PATH, PTRMapWidgetCommandType.START_AND_FOCUS])
+@StringDef(value = [PTRMapWidgetCommandType.SITE, PTRMapWidgetCommandType.BUILDING, PTRMapWidgetCommandType.LEVEL, PTRMapWidgetCommandType.POI, PTRMapWidgetCommandType.PATH, PTRMapWidgetCommandType.STATIC_PATH, PTRMapWidgetCommandType.STATIC_WAYFINDING, PTRMapWidgetCommandType.START_AND_FOCUS])
 annotation class PTRMapWidgetCommandType {
     companion object {
         const val SITE = "site"
@@ -11,6 +11,7 @@ annotation class PTRMapWidgetCommandType {
         const val POI = "poi"
         const val PATH = "path"
         const val STATIC_PATH = "staticPath"
+        const val STATIC_WAYFINDING = "staticWayfinding"
         const val MARK_MY_CAR_LEVEL = "markMyCarForLevel"
         const val MARK_MY_CAR_SITE = "markMyCarForSite"
         const val SHOW_MY_CAR_SITE = "showMyCarForSite"

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

@@ -27,15 +27,20 @@ import com.pointrlabs.core.management.models.deeplink.PTRMapWidgetMarkMyCarActio
 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.WayfindingEventsListener
 import com.pointrlabs.ui.map.views.PTRMapFragment
 import com.pointrlabs.ui.map.views.PTRMapWidgetFragment
 import com.pointrlabs.ui.map.views.wayfinding.MarkMyCarBottomSheet
@@ -44,24 +49,28 @@ import java.util.concurrent.Semaphore
 
 @SuppressLint("LogNotTimber")
 class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
-    ViewGroupManager<FrameLayout>(), MapEventsListener, MarkMyCarDetailsEventsListener {
+    ViewGroupManager<FrameLayout>(), MapEventsListener, MarkMyCarDetailsEventsListener, WayfindingEventsListener {
 
     override fun getName() = REACT_CLASS
 
     private lateinit var frameLayout: FrameLayout
 
+    private var ptrMapWidgetFragment: PTRMapWidgetFragment? = null
+
     private fun getMapWidgetFragment(action: PTRMapWidgetAction): PTRMapWidgetFragment {
-        Log.i("PTRMapWidgetManager", "Creating map widget fragment with action: $action")
+        Log.i(name, "Creating map widget fragment with action: $action")
         waitForPointrToRun()
-        val ptrMapWidgetFragment = PTRMapWidgetFragment.newInstance(
+        ptrMapWidgetFragment?.removeListener(this)
+        ptrMapWidgetFragment = PTRMapWidgetFragment.newInstance(
             (reactContext.currentActivity as FragmentActivity).supportFragmentManager,
             frameLayout.id,
             PointrModule.mapWidgetConfiguration,
             action
         )
         Choreographer.getInstance().postFrameCallback(frameCallback)
-        ptrMapWidgetFragment.addListener(this)
-        return ptrMapWidgetFragment
+        Log.v(name, "Adding itself as listener to map widget")
+        ptrMapWidgetFragment?.addListener(this)
+        return ptrMapWidgetFragment!!
     }
 
     /**
@@ -145,7 +154,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                         )
                         return@onComplete
                     }
-                    Plog.i("Focus action completed, showing static path")
+                    Log.i(name, "Focus action completed, showing static path")
 
                     showStaticPath(
                         ptrMapWidgetFragment,
@@ -157,6 +166,15 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 return
             }
 
+            PTRMapWidgetCommandType.STATIC_WAYFINDING -> {
+                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)
+            }
+
             PTRMapWidgetCommandType.MARK_MY_CAR_SITE -> {
                 val siteId = args.getString(0).orEmpty()
                 val location = PTRMapWidgetSiteLocation(siteId, isExternalIdentifier = true)
@@ -287,6 +305,13 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 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 -> {
                 event.putString("siteExternalIdentifier", args[0] as String)
                 event.putBoolean("shouldShowPopup", args[1] as Boolean)
@@ -351,6 +376,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 return
             }
         }
+        Log.v(name, "sending onMapWidgetDidEndLoading with event: $event")
         reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(
             frameLayout.id,
             "onMapWidgetDidEndLoading",
@@ -358,12 +384,29 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         )
     }
 
+    private fun onWayfindingEvent(type: Int, poi: Poi?) {
+        val event: WritableMap = WritableNativeMap()
+        event.putInt("type" , type)
+        event.putMap("poi", poi?.map)
+        Log.v(name, "Sending event for wayfinding: $event")
+        reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(
+            frameLayout.id,
+            "onWayfindingEvent",
+            event
+        )
+    }
+
     override fun getExportedCustomBubblingEventTypeConstants(): Map<String, Any> {
         return mapOf(
             "onMapWidgetDidEndLoading" to mapOf(
                 "phasedRegistrationNames" to mapOf(
                     "bubbled" to "onMapWidgetDidEndLoading"
                 )
+            ),
+            "onWayfindingEvent" to mapOf(
+                "phasedRegistrationNames" to mapOf(
+                    "bubbled" to "onWayfindingEvent"
+                )
             )
         )
     }
@@ -461,7 +504,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                 )
                 return@addLayer
             }
-            Log.i("PTRMapWidgetManager", "Static path layer added successfully")
+            Log.i(name, "Static path layer added successfully")
 
             ptrMapWidgetFragment.mapFragment?.addFeatures(
                 listOf(source, target),
@@ -477,7 +520,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
                     )
                     return@addFeatures
                 }
-                Log.i("PTRMapWidgetManager", "POI features added successfully")
+                Log.i(name, "POI features added successfully")
                 ptrMapWidgetFragment.mapFragment?.currentRoute = route
                 mapWidgetDidEndLoading(
                     PTRMapWidgetCommandType.STATIC_PATH,
@@ -607,12 +650,12 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
 
     override fun mapDidEndLoading(mapFragment: PTRMapFragment) {
         super.mapDidEndLoading(mapFragment)
-        Log.i("PTRMapWidgetManager", "Map loaded")
+        Log.i(name, "Map loaded")
     }
 
     override fun mapDidFailToLoad(mapFragment: PTRMapFragment, ptrError: PTRError) {
         super.mapDidFailToLoad(mapFragment, ptrError)
-        Log.e("PTRMapWidgetManager", "Map failed to load: $ptrError")
+        Log.e(name, "Map failed to load: $ptrError")
     }
 
     override fun onMarkMyCarDetailsEvent(
@@ -620,7 +663,7 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         markMyCarDetailsEvent: MarkMyCarDetailsEvent
     ) {
         super.onMarkMyCarDetailsEvent(markMyCarSheet, markMyCarDetailsEvent)
-        Plog.i("Mark my car details event: $markMyCarDetailsEvent")
+        Log.i(name, "Mark my car details event: $markMyCarDetailsEvent")
     }
 
     private val frameCallback = object : Choreographer.FrameCallback {
@@ -640,6 +683,25 @@ class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
         }
     }
 
+    override fun wayfindingDidShown() {
+        Log.v(name, "Wayfinding did shown")
+        val destination = (ptrMapWidgetFragment?.mapFragment?.currentRouteSession?.destination as? Poi)
+        onWayfindingEvent(0, destination)
+
+    }
+
+    override fun wayfindingDidTapClose() {
+        Log.v(name, "Wayfinding cancelled")
+        val destination = (ptrMapWidgetFragment?.mapFragment?.currentRouteSession?.destination as? Poi)
+        onWayfindingEvent(-1, destination)
+    }
+
+    override fun wayfindingDone() {
+        Log.v(name, "Wayfinding done")
+        val destination = (ptrMapWidgetFragment?.mapFragment?.currentRouteSession?.destination as? Poi)
+        onWayfindingEvent(1, destination)
+    }
+
     companion object {
         const val REACT_CLASS = "PTRMapWidget"
         const val LAYER_STATIC_PATH = "sym-static-path"

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

@@ -8,11 +8,16 @@ import android.os.Parcelable
 import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.pointrlabs.core.geofence.GeofenceEvent
+import com.pointrlabs.core.geofence.GeofenceEventType
+import com.pointrlabs.core.geofence.GeofenceType
+import com.pointrlabs.core.management.GeofenceManager
 import com.pointrlabs.core.management.Pointr
 import com.pointrlabs.core.management.PositioningManager
 import com.pointrlabs.core.management.interfaces.PointrListener
@@ -20,6 +25,7 @@ import com.pointrlabs.core.management.models.Building
 import com.pointrlabs.core.management.models.PTRParams
 import com.pointrlabs.core.management.models.Site
 import com.pointrlabs.core.nativecore.wrappers.Plog
+import com.pointrlabs.core.poi.models.Poi
 import com.pointrlabs.core.positioning.model.CalculatedPosition
 import com.pointrlabs.core.positioning.model.PositioningTypes
 import com.pointrlabs.core.util.models.error.PTRError
@@ -36,6 +42,7 @@ class PointrModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
     private val positionManagerListener: PositioningManager.Listener
+    private val geofenceListener : GeofenceManager.Listener
     private var listenerCount = 0
 
     init {
@@ -45,6 +52,12 @@ class PointrModule(reactContext: ReactApplicationContext) :
                 sendEventToJs(reactContext, OnPositionManagerCalculatedLocation, params)
             }
         }
+        geofenceListener = object : GeofenceManager.Listener {
+            override fun onGeofenceManagerGeofenceEvent(geofenceEvent: GeofenceEvent) {
+                val params = buildParamsForGeofenceEvent(geofenceEvent)
+                sendEventToJs(reactContext, OnGeofenceEvent, params)
+            }
+        }
         setPointrListeners()
     }
 
@@ -70,7 +83,7 @@ class PointrModule(reactContext: ReactApplicationContext) :
             Log.e("Pointr", "Permission manager is not ready")
             return
         }
-        val activity = currentActivity ?: run {
+        val activity = reactApplicationContext.currentActivity ?: run {
             Log.e("Pointr", "Could not get current activity")
             return
         }
@@ -111,7 +124,7 @@ class PointrModule(reactContext: ReactApplicationContext) :
         clientId: String,
         licenceKey: String,
         baseUrl: String,
-        logLevel: Int
+        logLevel: Int = 0
     ) {
         initialize(
             reactApplicationContext,
@@ -171,6 +184,40 @@ class PointrModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun getPois(siteId: String, promise: Promise) {
+        try {
+            Log.v(name, "get pois called $siteId")
+            // Ensure Pointr SDK is initialized
+            val site = Pointr.getPointr()?.siteManager?.getSiteByExternalIdentifier(siteId)
+
+            if (site == null) {
+                Log.e(name, "Site is null")
+                promise.reject("ERROR", "Site not found: $siteId")
+                return
+            }
+
+            Log.v(name, "getting pois")
+
+            // Get all POIs for the site
+            val pois = Pointr.getPointr()?.poiManager?.getPois(site)?.poiList ?: emptyList()
+
+            Log.v(name, "found ${pois.size} pois")
+
+            // Convert POIs to WritableArray
+            val poisArray = Arguments.createArray()
+
+            pois.forEach { poi ->
+                poisArray.pushMap(poi.map)
+            }
+
+            promise.resolve(poisArray)
+
+        } catch (e: Exception) {
+            promise.reject("ERROR", "Failed to get POIs: ${e.message}", e)
+        }
+    }
+
     companion object {
         const val NAME = "PTRNativePointrLibrary"
         val mapWidgetConfiguration = PTRMapWidgetConfiguration.defaultConfiguration()
@@ -189,6 +236,8 @@ class PointrModule(reactContext: ReactApplicationContext) :
         const val OnBuildingClicked = "OnBuildingClicked"
         const val OnSiteClicked = "OnSiteClicked"
 
+        const val OnGeofenceEvent = "OnGeofenceEvent"
+
         var shouldRequestPermissionsAtStartup = true
 
         fun sendEventToJs(
@@ -305,6 +354,9 @@ class PointrModule(reactContext: ReactApplicationContext) :
             dialog.setCanceledOnTouchOutside(false)
             dialog.show()
         }
+
+
+
         // endregion [com.pointrlabs.core.map.models.events_listeners.CustomMapEventsListener]
     }
 
@@ -343,7 +395,7 @@ class PointrModule(reactContext: ReactApplicationContext) :
         clientId: String,
         licenceKey: String,
         baseUrl: String,
-        logLevel: Int
+        logLevel: Int = 0
     ) {
         val ptrParams = PTRParams(clientId, licenceKey, baseUrl)
         try {
@@ -355,6 +407,55 @@ class PointrModule(reactContext: ReactApplicationContext) :
         Pointr.with(reactContext, ptrParams)
     }
 
+    private fun buildParamsForGeofenceEvent(geofenceEvent: GeofenceEvent): WritableMap {
+        val params: WritableMap = Arguments.createMap()
+
+        //TODO: Add PTRGeofenceEvent's timestamp
+
+        // Event type (enter, exit)
+        val eventType = when (geofenceEvent.type) {
+            GeofenceEventType.Enter -> "enter"
+            else -> "exit"
+        }
+        params.putString("eventType", eventType)
+
+        // Geofence information
+        val geofence = geofenceEvent.geofence
+        val geofenceMap = Arguments.createMap().apply {
+            putString("id", geofence.identifier)
+            putString("externalId", geofence.externalIdentifier)
+            putString("name", geofence.name)
+
+            val geofenceType = when (geofence.type) {
+                GeofenceType.GPS -> "gps"
+                else -> "beacon"
+            }
+            params.putString("geofenceType", geofenceType)
+
+            // Position information
+            val position = geofence.position
+            val positionMap = Arguments.createMap().apply {
+                putDouble("latitude", position.lat)
+                putDouble("longitude", position.lon)
+            }
+            putMap("position", positionMap)
+        }
+
+        params.putMap("geofence", geofenceMap)
+
+        // Geofence notification information if available
+        geofenceEvent.geofenceNotification?.let { notification ->
+            val notificationMap = Arguments.createMap().apply {
+                putString("id", notification.id)
+                putString("message", notification.message)
+                putLong("timestamp", notification.timeStamp)
+            }
+            params.putMap("geofenceNotification", notificationMap)
+        }
+
+        return params
+    }
+
     private fun onPointrStartEnded(action: (String) -> Unit) {
         val pointr = Pointr.getPointr() ?: return
         pointr.addListener(object : PointrListener {
@@ -373,12 +474,14 @@ class PointrModule(reactContext: ReactApplicationContext) :
         val pointr = Pointr.getPointr() ?: return
         if (pointr.state != Pointr.State.RUNNING) return
         pointr.positioningManager?.removeListener(positionManagerListener)
+        pointr.geofenceManager?.removeListener(geofenceListener)
     }
 
     private fun setPointrListeners() {
         val pointr = Pointr.getPointr() ?: return
         if (pointr.state != Pointr.State.RUNNING) return
         pointr.positioningManager?.addListener(positionManagerListener)
+        pointr.geofenceManager?.addListener(geofenceListener)
         if (shouldRequestPermissionsAtStartup) {
             requestPermissions()
         } else {

package/example/pointr_rn_demo/.bundle/config

@@ -0,0 +1,2 @@
+BUNDLE_PATH: "vendor/bundle"
+BUNDLE_FORCE_RUBY_PLATFORM: 1

package/example/pointr_rn_demo/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: '@react-native',
+};

package/example/pointr_rn_demo/.prettierrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  arrowParens: 'avoid',
+  singleQuote: true,
+  trailingComma: 'all',
+};

package/example/pointr_rn_demo/.watchmanconfig

@@ -0,0 +1 @@
+{}