react-native-pointr 8.14.0 → 8.14.3

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

@@ -0,0 +1,605 @@
+package com.pointr
+
+import android.annotation.SuppressLint
+import android.util.Log
+import android.view.Choreographer
+import android.view.View
+import android.widget.FrameLayout
+import androidx.fragment.app.FragmentActivity
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.pointrlabs.core.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.Site
+import com.pointrlabs.core.map.models.PTRError
+import com.pointrlabs.core.map.models.PTRMapSymbolLayer
+import com.pointrlabs.core.map.models.events_listeners.MapEventsListener
+import com.pointrlabs.core.map.viewmodels.PTRMapWidgetConfiguration
+import com.pointrlabs.core.map.views.PTRMapFragment
+import com.pointrlabs.core.map.views.PTRMapWidgetFragment
+import com.pointrlabs.core.nativecore.wrappers.Plog
+import com.pointrlabs.core.pathfinding.PathManager
+import com.pointrlabs.core.positioning.model.PositioningTypes
+import com.pointrlabs.core.site.SiteManager
+import java.util.concurrent.Semaphore
+
+
+@SuppressLint("LogNotTimber")
+class PTRMapWidgetManager(private val reactContext: ReactApplicationContext) :
+    ViewGroupManager<FrameLayout>(), MapEventsListener {
+
+    override fun getName() = REACT_CLASS
+
+    private lateinit var frameLayout: FrameLayout
+
+    private var _ptrMapWidgetFragment: PTRMapWidgetFragment? = null
+    private val ptrMapWidgetFragment: PTRMapWidgetFragment?
+        get() {
+            _ptrMapWidgetFragment?.let { return it }
+            Log.i("PTRMapWidgetManager", "Creating map widget fragment")
+            _ptrMapWidgetFragment = createMapWidgetFragment()
+            Choreographer.getInstance().postFrameCallback(frameCallback)
+            _ptrMapWidgetFragment?.addListener(this)
+            return _ptrMapWidgetFragment
+        }
+
+    private fun createMapWidgetFragment(): PTRMapWidgetFragment {
+        waitForPointrToRun()
+        // TODO: wait for configuration to be ready
+        val configuration = PointrMapWidgetActivity.mapWidgetConfiguration
+        configuration.isExitButtonShown = false
+        @Suppress("DEPRECATION")
+        val widget = PTRMapWidgetFragment.newInstance(configuration).show(
+            (reactContext.currentActivity as FragmentActivity).supportFragmentManager,
+            frameLayout.id
+        )
+        return widget
+    }
+
+    /**
+     * Return a FrameLayout which will later hold the Fragment
+     */
+    override fun createViewInstance(reactContext: ThemedReactContext): FrameLayout {
+        frameLayout = FrameLayout(reactContext)
+        return frameLayout
+    }
+
+    /**
+     * Handle "create" command (called from JS) and call createFragment method
+     */
+    override fun receiveCommand(
+        root: FrameLayout, command: String, args: ReadableArray?
+    ) {
+        super.receiveCommand(root, command, args)
+        val args1 = args ?: return
+        val ptrMapWidgetFragment = this.ptrMapWidgetFragment ?: run {
+            Log.e(
+                "PTRMapWidgetManager",
+                "PTRMapWidgetFragment is null"
+            )
+            return
+        }
+        clearPath(ptrMapWidgetFragment)
+        executeCommand(ptrMapWidgetFragment, command, args1)
+    }
+
+    private fun clearPath(ptrMapWidgetFragment: PTRMapWidgetFragment) {
+        ptrMapWidgetFragment.mapFragment?.removeAllFeatures { isSuccess, message ->
+            if (!isSuccess) {
+                Log.e(
+                    "PTRMapWidgetManager",
+                    "Error removing features: $message"
+                )
+            }
+            ptrMapWidgetFragment.mapFragment?.removeLayer(LAYER_STATIC_PATH) { b, e ->
+                if (!b) {
+                    Log.e(
+                        "PTRMapWidgetManager",
+                        "Error removing layer: $e"
+                    )
+                }
+                ptrMapWidgetFragment.mapFragment?.currentPath = null
+                ptrMapWidgetFragment.mapFragment?.currentPathSession?.abort()
+            }
+        }
+    }
+
+    private fun executeCommand(
+        ptrMapWidgetFragment: PTRMapWidgetFragment,
+        command: String,
+        args1: ReadableArray
+    ) {
+        when (command) {
+            PTRMapWidgetCommandType.SITE -> showSite(ptrMapWidgetFragment, args1.getString(0))
+            PTRMapWidgetCommandType.BUILDING -> showBuilding(
+                ptrMapWidgetFragment,
+                args1.getString(0),
+                args1.getString(1)
+            )
+
+            PTRMapWidgetCommandType.LEVEL -> showLevel(
+                ptrMapWidgetFragment,
+                args1.getString(0),
+                args1.getString(1),
+                args1.getInt(2)
+            )
+
+            PTRMapWidgetCommandType.POI -> showPoi(
+                ptrMapWidgetFragment,
+                args1.getString(0),
+                args1.getString(1)
+            )
+
+            PTRMapWidgetCommandType.PATH -> showPath(
+                ptrMapWidgetFragment,
+                args1.getString(0),
+                args1.getString(1)
+            )
+
+            PTRMapWidgetCommandType.STATIC_PATH -> showStaticPath(
+                ptrMapWidgetFragment,
+                args1.getString(0),
+                args1.getString(1),
+                args1.getString(2)
+            )
+
+            else -> return
+        }
+    }
+
+    private fun mapWidgetDidEndLoading(
+        @PTRMapWidgetCommandType command: String,
+        vararg args: Any
+    ) {
+        val event: WritableMap = WritableNativeMap()
+        event.putString("command", command)
+        when (command) {
+            PTRMapWidgetCommandType.SITE -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putString("error", args[1] as String)
+            }
+
+            PTRMapWidgetCommandType.BUILDING -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putString("buildingExternalIdentifier", args[1] as String)
+                event.putString("error", args[2] as String)
+            }
+
+            PTRMapWidgetCommandType.LEVEL -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putString("buildingExternalIdentifier", args[1] as String)
+                event.putInt("levelIndex", args[2] as Int)
+                event.putString("error", args[3] as String)
+            }
+
+            PTRMapWidgetCommandType.POI -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putString("poiExternalIdentifier", args[1] as String)
+                event.putString("error", args[2] as String)
+            }
+
+            PTRMapWidgetCommandType.PATH -> {
+                event.putString("siteExternalIdentifier", args[0] as String)
+                event.putString("poiExternalIdentifier", args[1] as String)
+                event.putString("error", args[2] as String)
+            }
+
+            PTRMapWidgetCommandType.STATIC_PATH -> {
+                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)
+            }
+
+            else -> {
+                return
+            }
+        }
+        reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(
+            frameLayout.id,
+            "onMapWidgetDidEndLoading",
+            event
+        )
+    }
+
+    override fun getExportedCustomBubblingEventTypeConstants(): Map<String, Any> {
+        return mapOf(
+            "onMapWidgetDidEndLoading" to mapOf(
+                "phasedRegistrationNames" to mapOf(
+                    "bubbled" to "onMapWidgetDidEndLoading"
+                )
+            )
+        )
+    }
+
+
+    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 pathManager = Pointr.getPointr()?.pathManager ?: run {
+            mapWidgetDidEndLoading(
+                PTRMapWidgetCommandType.STATIC_PATH,
+                site,
+                fromPoi,
+                toPoi,
+                "Path manager not found"
+            )
+            return
+        }
+        val path = pathManager.calculatePath(source, listOf(target)) ?: run {
+            mapWidgetDidEndLoading(
+                PTRMapWidgetCommandType.STATIC_PATH,
+                site,
+                fromPoi,
+                toPoi,
+                "Path not found"
+            )
+            return
+        }
+        val onCompleted = { error: String? ->
+            error?.let {
+                mapWidgetDidEndLoading(
+                    PTRMapWidgetCommandType.STATIC_PATH,
+                    site,
+                    fromPoi,
+                    toPoi,
+                    "Error loading the map: $it"
+                )
+                Plog.e("Error showing level: $it")
+                return@let
+            }
+            ptrMapWidgetFragment.focusOnCoordinate(
+                source.location.site?.internalIdentifier ?: PositioningTypes.INVALID_INTEGER,
+                source.location.building?.internalIdentifier ?: PositioningTypes.INVALID_INTEGER,
+                source.location.level?.index ?: PositioningTypes.INVALID_INTEGER,
+                source.location.lat,
+                source.location.lon
+            ) {
+                val layer = PTRMapSymbolLayer(LAYER_STATIC_PATH)
+                val mapFragment = ptrMapWidgetFragment.mapFragment ?: return@focusOnCoordinate
+                mapFragment.addLayer(layer) { b1, e1 ->
+                    if (!b1) {
+                        mapWidgetDidEndLoading(
+                            PTRMapWidgetCommandType.STATIC_PATH,
+                            site,
+                            fromPoi,
+                            toPoi,
+                            "Error adding layer: $e1"
+                        )
+                        Plog.e("Error adding layer: $e1")
+                        return@addLayer
+                    }
+                    mapFragment.addFeatures(
+                        listOf(source, target), layer.identifier
+                    ) { b2, e2 ->
+                        if (!b2) {
+                            mapWidgetDidEndLoading(
+                                PTRMapWidgetCommandType.STATIC_PATH,
+                                site,
+                                fromPoi,
+                                toPoi,
+                                "Error adding features: $e2"
+                            )
+                            Plog.e("Error adding features: $e2")
+                            return@addFeatures
+                        }
+                        mapFragment.currentPath = path
+                        mapWidgetDidEndLoading(
+                            PTRMapWidgetCommandType.STATIC_PATH,
+                            site,
+                            fromPoi,
+                            toPoi,
+                            ""
+                        )
+                        Plog.i("Path shown")
+                    }
+                }
+            }
+        }
+        source.level?.let {
+            ptrMapWidgetFragment.showLevel(it, onComplete = onCompleted)
+        } ?: ptrMapWidgetFragment.showSite(
+            source.location.site?.internalIdentifier ?: 0, onComplete = onCompleted
+        )
+
+    }
+
+    private fun showPath(ptrMapWidgetFragment: PTRMapWidgetFragment, site: String, toPoi: String) {
+        ptrMapWidgetFragment.showPathFinding(site, toPoi) { error ->
+            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
+                PTRMapWidgetCommandType.PATH,
+                site,
+                toPoi,
+                error ?: ""
+            )
+            error?.let {
+                Plog.e("Error showing path: $it")
+                return@showPathFinding
+            }
+            Plog.i("Path shown")
+        }
+    }
+
+    private fun showPoi(ptrMapWidgetFragment: PTRMapWidgetFragment, site: String, poi: String) {
+        ptrMapWidgetFragment.showPoiDetails(site, poi) { error ->
+            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
+                PTRMapWidgetCommandType.POI,
+                site,
+                poi,
+                error ?: ""
+            )
+            error?.let {
+                Plog.e("Error showing poi: $it")
+                return@showPoiDetails
+            }
+            Plog.i("Poi shown")
+        }
+    }
+
+    private fun showLevel(
+        ptrMapWidgetFragment: PTRMapWidgetFragment,
+        site: String,
+        building: String,
+        level: Int
+    ) {
+        ptrMapWidgetFragment.showLevel(site, building, level) showLevelInternal@{ error ->
+            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
+                PTRMapWidgetCommandType.LEVEL,
+                site,
+                building,
+                level,
+                error ?: ""
+            )
+            error?.let {
+                Plog.e("Error showing level: $it")
+                return@showLevelInternal
+            }
+            Plog.i("Level shown")
+        }
+    }
+
+    private fun showBuilding(
+        ptrMapWidgetFragment: PTRMapWidgetFragment,
+        site: String,
+        building: String
+    ) {
+        ptrMapWidgetFragment.showBuilding(site, building) showBuildingInternal@{ error ->
+            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
+                PTRMapWidgetCommandType.BUILDING,
+                site,
+                building,
+                error ?: ""
+            )
+            error?.let {
+                Plog.e("Error showing building: $it")
+                return@showBuildingInternal
+            }
+            Plog.i("Building shown")
+        }
+    }
+
+    private fun showSite(ptrMapWidgetFragment: PTRMapWidgetFragment, site: String) {
+        ptrMapWidgetFragment.showSite(site) showSiteInternal@{ error ->
+            this@PTRMapWidgetManager.mapWidgetDidEndLoading(
+                PTRMapWidgetCommandType.SITE,
+                site,
+                error ?: ""
+            )
+            error?.let {
+                Plog.e("Error showing site: $it")
+                return@showSiteInternal
+            }
+            Plog.i("Site shown")
+        }
+    }
+
+    // region Show path
+
+    private fun waitForPathManager(theSite: Site): Boolean {
+        val pathManager = Pointr.getPointr()?.pathManager ?: return false
+        val semaphore = Semaphore(0)
+        val listener = object : PathManager.Listener {
+            override fun onPathManagerReadyForSite(site: Site) {
+                if (site != theSite) return
+                semaphore.release()
+            }
+        }
+        pathManager.addListener(listener)
+        if (!pathManager.isReadyForSite(theSite)) {
+            semaphore.tryAcquire(15, java.util.concurrent.TimeUnit.SECONDS)
+        }
+        pathManager.removeListener(listener)
+        return pathManager.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(site: String): Site? {
+        val siteManager = Pointr.getPointr()?.siteManager ?: return null
+        val semaphore = Semaphore(0)
+        val listener = object : SiteManager.Listener {
+            override fun onSiteManagerDataChanged() {
+                semaphore.release()
+            }
+        }
+        siteManager.addListener(listener)
+        if (siteManager.getSites().isEmpty()) {
+            semaphore.tryAcquire(10, java.util.concurrent.TimeUnit.SECONDS)
+        }
+        siteManager.removeListener(listener)
+        return siteManager.getSite(site)
+    }
+
+    // endregion
+
+    private fun waitForPointrToRun(): Boolean {
+        Log.e(
+            "PTRMapWidgetManager",
+            "Waiting for Pointr to run"
+        )
+        val semaphore = Semaphore(0)
+        val listener = object : PointrListener {
+            override fun onStateUpdated(p0: Pointr.State?) {
+                Log.e(
+                    "PTRMapWidgetManager",
+                    "Pointr state updated to: $p0"
+                )
+                val state = p0 ?: return
+                if (state.`val` < Pointr.State.OFF.`val` || state == Pointr.State.RUNNING) {
+                    semaphore.release()
+                    return
+                }
+            }
+        }
+        Log.e(
+            "PTRMapWidgetManager",
+            "Adding listener to Pointr"
+        )
+        Pointr.getPointr()?.addListener(listener)
+        Log.e(
+            "PTRMapWidgetManager",
+            "Pointr state: ${Pointr.getPointr()?.state}"
+        )
+        if (Pointr.getPointr()?.state == Pointr.State.RUNNING) {
+            Log.e(
+                "PTRMapWidgetManager",
+                "Already running Pointr"
+            )
+            Pointr.getPointr()?.removeListener(listener)
+            return true
+        }
+        Log.e(
+            "PTRMapWidgetManager",
+            "Starting Pointr"
+        )
+        Pointr.getPointr()?.start()
+        Log.e(
+            "PTRMapWidgetManager",
+            "Pointr started"
+        )
+        semaphore.tryAcquire(10, java.util.concurrent.TimeUnit.SECONDS)
+        Log.e(
+            "PTRMapWidgetManager",
+            "Final Pointr state: ${Pointr.getPointr()?.state}"
+        )
+        Pointr.getPointr()?.removeListener(listener)
+        return Pointr.getPointr()?.state == Pointr.State.RUNNING
+    }
+
+    override fun mapDidEndLoading(mapFragment: PTRMapFragment) {
+        super.mapDidEndLoading(mapFragment)
+        Log.i("PTRMapWidgetManager", "Map loaded")
+    }
+
+    override fun mapDidFailToLoad(mapFragment: PTRMapFragment, ptrError: PTRError) {
+        super.mapDidFailToLoad(mapFragment, ptrError)
+        Log.e("PTRMapWidgetManager", "Map failed to load: $ptrError")
+    }
+
+    private val frameCallback = object : Choreographer.FrameCallback {
+        override fun doFrame(frameTimeNanos: Long) {
+            frameLayout.measure(
+                View.MeasureSpec.makeMeasureSpec(frameLayout.width, View.MeasureSpec.EXACTLY),
+                View.MeasureSpec.makeMeasureSpec(frameLayout.height, View.MeasureSpec.EXACTLY)
+            )
+            frameLayout.layout(
+                frameLayout.left,
+                frameLayout.top,
+                frameLayout.right,
+                frameLayout.bottom
+            )
+            frameLayout.viewTreeObserver.dispatchOnGlobalLayout()
+            Choreographer.getInstance().postFrameCallback(this)
+        }
+    }
+
+    companion object {
+        const val REACT_CLASS = "PTRMapWidget"
+        const val LAYER_STATIC_PATH = "sym-static-path"
+    }
+
+}