react-native-pointr 0.0.0

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

@@ -0,0 +1,466 @@
+package com.pointr
+
+import android.annotation.SuppressLint
+import android.content.ComponentName
+import android.content.Intent
+import android.os.Parcel
+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.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.management.Pointr
+import com.pointrlabs.core.management.PositionManager
+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.events_listeners.MapEventsListener
+import com.pointrlabs.core.map.views.PTRMapFragment
+import com.pointrlabs.core.nativecore.wrappers.Plog.LogLevel
+import com.pointrlabs.core.nativecore.wrappers.Plog.v
+import com.pointrlabs.core.positioning.model.CalculatedLocation
+import com.pointrlabs.core.positioning.model.PositioningTypes
+import org.json.JSONObject
+import kotlin.reflect.KMutableProperty1
+
+@SuppressLint("LogNotTimber")
+class PointrModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    init {
+        setPointrListeners()
+    }
+
+    private var listenerCount = 0
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // TODO as per documentation, this should get invoked when addListener is called
+        // on the JS side, but it does not get invoked
+        if (listenerCount == 0) {
+            // Set up any upstream listeners or background tasks as necessary
+            start { args -> v("Pointr started and listeners added") }
+        }
+        listenerCount += 1
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        listenerCount -= count
+        if (listenerCount == 0) {
+            // Remove upstream listeners, stop unnecessary background tasks
+            removePointrListeners()
+        }
+    }
+
+    @ReactMethod
+    fun initialize(
+        licenceKey: String,
+        baseUrl: String,
+        clientId: String,
+        env: String,
+        logLevel: Int
+    ) {
+        initialize(
+            reactApplicationContext,
+            clientId,
+            baseUrl,
+            licenceKey,
+            env,
+            logLevel
+        )
+    }
+
+    @ReactMethod
+    fun start(callback: Callback?) {
+        Pointr.getPointr()?.let {
+            if (it.state == Pointr.State.RUNNING) {
+                setPointrListeners()
+                callback?.invoke(it.state.name)
+            } else {
+                onPointrStartEnded { endState ->
+                    callback?.invoke(endState)
+                }
+                Thread {
+                    it.start()
+                }.start()
+            }
+        }
+    }
+
+    @ReactMethod
+    fun stop() {
+        Pointr.getPointr()?.stop()
+    }
+
+    @ReactMethod
+    fun getCurrentLocation(callback: Callback) {
+        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)
+        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 {
+            val jsonObject = JSONObject(configurationString)
+            setPointrMapWidgetConfiguration(jsonObject)
+        } catch (e: Exception) {
+            Log.e(name, "Unable to parse configuration!")
+        }
+    }
+
+    companion object {
+        const val NAME = "PTRNativePointrLibrary"
+
+        const val siteInternalIdentifierKey = "siteInternalIdentifier"
+        const val siteExternalIdentifierKey = "siteExternalIdentifier"
+        const val buildingInternalIdentifierKey = "buildingInternalIdentifier"
+        const val buildingExternalIdentifierKey = "buildingExternalIdentifier"
+        const val levelIndexKey = "levelIndex"
+        const val latitudeKey = "latitude"
+        const val longitudeKey = "longitude"
+        const val accuracyKey = "accuracy"
+        const val headingKey = "heading"
+        const val mapEventsListenerKey = "mapEventsListener"
+
+        const val OnPositionManagerCalculatedLocation = "OnPositionManagerCalculatedLocation"
+        const val OnBuildingClicked = "OnBuildingClicked"
+        const val OnSiteClicked = "OnSiteClicked"
+
+
+
+        fun sendEventToJs(
+            reactContext: ReactApplicationContext,
+            nameOfEvent: String,
+            params: WritableMap? = null
+        ) {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(nameOfEvent, params)
+        }
+    }
+
+
+    /**
+     * This class is where extra actions regarding Pointr are performed. It is always invoked from the
+     * actual entry point PointrLibraryModule.java. All of the apis are using external identifier
+     *
+     * This can be;
+     * - Showing a specific site
+     * - Showing a specific building
+     * - Showing a specific level
+     * - Showing a specific Poi
+     * - Pathfinding to a specific Poi
+     * - Getting current location
+     *
+     * We show an example of how to communicate from this class to the JS classes using an EventEmitter,
+     * for the PositionManager callback. Similarly in the App.js class there is an EventEmitter created
+     * which listens to this event.
+     */
+
+    private val positionManagerListener = object : PositionManager.Listener {
+        override fun onPositionManagerCalculatedLocation(p0: CalculatedLocation?) {
+            val calculatedLocation = p0 ?: return
+            val params = applyParamsForCalculatedLocation(calculatedLocation)
+            sendEventToJs(reactContext, OnPositionManagerCalculatedLocation, params)
+        }
+
+        override fun onPositionManagerDetectedPositionLevelChange(p0: Level) {}
+        override fun onPositionManagerPositionIsFading() {}
+        override fun onPositionManagerPositionIsLost() {}
+        override fun onPositionManagerPositioningServiceStateChangedTo(p0: PositioningTypes.PositioningServiceState?) {}
+    }
+
+    open class CustomMapEventsListener() : MapEventsListener, Parcelable {
+
+        private var reactContext: ReactApplicationContext? = null
+
+        constructor(reactContext: ReactApplicationContext) : this() {
+            this.reactContext = reactContext
+        }
+
+        constructor(parcel: Parcel) : this() {
+        }
+
+        // region [android.os.Parcelable]
+        override fun writeToParcel(parcel: Parcel, flags: Int) {
+
+        }
+
+        override fun describeContents(): Int {
+            return 0
+        }
+
+        companion object CREATOR : Parcelable.Creator<CustomMapEventsListener>,
+            MapEventsListener {
+
+            const val INTERNAL_ID = "internalIdentifier"
+            const val EXTERNAL_ID = "externalIdentifier"
+            const val TITLE = "title"
+
+            override fun createFromParcel(parcel: Parcel): CustomMapEventsListener {
+                return CustomMapEventsListener(parcel)
+            }
+
+            override fun newArray(size: Int): Array<CustomMapEventsListener?> {
+                return arrayOfNulls(size)
+            }
+        }
+        // endregion [android.os.Parcelable]
+
+        // 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(EXTERNAL_ID, building.externalIdentifier)
+            params.putString(TITLE, building.title)
+            reactContext?.let {
+                sendEventToJs(it, OnBuildingClicked, params)
+            }
+        }
+
+        override fun mapDidReceiveTapOnSite(mapFragment: PTRMapFragment, site: Site) {
+            val params: WritableMap = Arguments.createMap()
+            params.putInt(INTERNAL_ID, site.internalIdentifier)
+            params.putString(EXTERNAL_ID, site.externalIdentifier)
+            params.putString(TITLE, site.title)
+            reactContext?.let {
+                sendEventToJs(it, OnSiteClicked, params)
+            }
+        }
+        // endregion [com.pointrlabs.core.map.models.events_listeners.CustomMapEventsListener]
+    }
+
+    private fun applyParamsForCalculatedLocation(calculatedLocation: CalculatedLocation): WritableMap {
+        val params: WritableMap = Arguments.createMap()
+        val site = calculatedLocation.site
+        val building = calculatedLocation.building
+        val level = calculatedLocation.level
+        val loc = calculatedLocation.location
+        site?.let {
+            params.putInt(siteInternalIdentifierKey, it.internalIdentifier)
+            params.putString(siteExternalIdentifierKey, it.externalIdentifier)
+        }
+        building?.let {
+            params.putInt(buildingInternalIdentifierKey, it.internalIdentifier)
+            params.putString(buildingExternalIdentifierKey, it.externalIdentifier)
+        }
+        level?.let {
+            params.putInt(levelIndexKey, it.index)
+        }
+        if (loc.lat != PositioningTypes.INVALID_FLOAT && loc.lon != PositioningTypes.INVALID_FLOAT) {
+            params.putDouble(latitudeKey, loc.lat)
+            params.putDouble(longitudeKey, loc.lon)
+        }
+        if (calculatedLocation.accuracy != PositioningTypes.INVALID_FLOAT) {
+            params.putDouble(accuracyKey, calculatedLocation.accuracy)
+        }
+        if (calculatedLocation.headingAccuracyClass == CalculatedLocation.HeadingAccuracyClass.HIGH) {
+            params.putDouble(headingKey, calculatedLocation.heading)
+        }
+        return params
+    }
+
+    fun initialize(
+        reactContext: ReactApplicationContext,
+        clientId: String,
+        baseUrl: String,
+        licenceKey: String,
+        env: 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 = LogLevel.values()[logLevel]
+            ptrParams.logLevel = ptrLogLevel
+        } catch (ex: IllegalArgumentException) {
+            Log.e(name, "Could not set log level of PTRParams for logLevel: $logLevel")
+        }
+        Pointr.with(reactContext, ptrParams)
+    }
+
+    private fun onPointrStartEnded(action: (String) -> Unit) {
+        val pointr = Pointr.getPointr() ?: return
+        pointr.addListener(object : PointrListener {
+            override fun onStateUpdated(p0: Pointr.State?) {
+                Log.v(name, "Pointr state updated: ${p0?.name}}")
+                val state = p0 ?: return
+                if (state.`val` > Pointr.State.OFF.`val` && state.`val` < Pointr.State.RUNNING.`val`) return
+                setPointrListeners()
+                action.invoke(state.name)
+                pointr.removeListener(this)
+            }
+        })
+    }
+
+    fun removePointrListeners() {
+        val pointr = Pointr.getPointr() ?: return
+        if (pointr.state != Pointr.State.RUNNING) return
+        pointr.positionManager?.removeListener(positionManagerListener)
+    }
+
+    private fun setPointrListeners() {
+        val pointr = Pointr.getPointr() ?: return
+        if (pointr.state != Pointr.State.RUNNING) return
+        pointr.positionManager?.addListener(positionManagerListener)
+    }
+
+    fun setPointrMapWidgetConfiguration(jsonObject: JSONObject) {
+        PointrMapWidgetActivity.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)
+            } catch (_: Exception) {
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,17 @@
+package com.pointr
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class PointrPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(PointrModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/res/layout/pointr_map_widget_activity_layout.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:id="@+id/pointr_map_widget_activity_layout"
+    xmlns:app="http://schemas.android.com/apk/res-auto">
+
+    <FrameLayout
+        android:id="@+id/fragment_container"
+        android:layout_width="0dp"
+        android:layout_height="0dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent"/>
+</androidx.constraintlayout.widget.ConstraintLayout>

package/android/src/main/res/values/strings.xml

@@ -0,0 +1 @@
+<resources></resources>

package/ios/PTRNativeLibrary.h

@@ -0,0 +1,19 @@
+//
+//  PTRNativeLibrary.h
+//  pointrSample
+//
+//  Created by Furkan Erdem Perşembe on 6.04.2020.
+//  Copyright © 2020 Pointr. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface PTRNativeLibrary : RCTEventEmitter
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/PTRNativeLibrary.m

@@ -0,0 +1,150 @@
+//
+//  PTRNativeLibrary.m
+//  pointrSample
+//
+//  Created by Furkan Erdem Perşembe on 6.04.2020.
+//  Copyright © 2020 Pointr. All rights reserved.
+//
+
+#import "PTRNativeLibrary.h"
+
+#import "react_native_pointr-Swift.h"
+#import <React/RCTUtils.h>
+
+@interface PTRNativeLibrary() <RCTBridgeModule, PTREventManagerDelegate>
+
+@end
+
+@implementation PTRNativeLibrary
+
+bool hasListeners;
+
+- (instancetype)init {
+  self = [super init];
+  PointrApp.sharedApp.eventManagerDelegate = self;
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+RCT_EXPORT_MODULE(PTRNativePointrLibrary);
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[@"OnPositionManagerCalculatedLocation", @"OnBuildingClicked", @"OnSiteClicked"];
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+// Will be called when this module's first listener is added.
+-(void)startObserving {
+  hasListeners = YES;
+}
+
+// Will be called when this module's last listener is removed, or on dealloc.
+-(void)stopObserving {
+  hasListeners = NO;
+}
+
+RCT_EXPORT_METHOD(initialize:(NSString *)licenseKey baseUrl:(NSString *)baseUrl clientIdentifier:(NSString *)clientIdentifier environment:(NSString *)environment logLevel:(int)logLevel) {
+  UIViewController *presentedViewController = RCTPresentedViewController();
+  [PointrApp.sharedApp initializeWithLicenseKey:licenseKey baseUrl:baseUrl clientIdentifier:clientIdentifier environment:environment logLevel:logLevel rootViewController:presentedViewController];
+}
+
+RCT_EXPORT_METHOD(start:(RCTResponseSenderBlock)callback) {
+  if (Pointr.shared.state == PointrStateRunning) {
+    callback(@[@"Pointr is already running"]);
+  } else {
+    [PointrApp.sharedApp startWithCompletion: ^(NSString *state) {
+      callback(@[state]);
+    }];
+  }
+}
+
+RCT_EXPORT_METHOD(stop) {
+  [PointrApp.sharedApp stop];
+}
+
+#pragma mark MapWidget
+
+RCT_EXPORT_METHOD(showSite:(NSString *)siteExternalIdentifier animationType:(int)animationType callback:(RCTResponseSenderBlock)callback) {
+  [PointrApp.sharedApp showSiteWithSiteExternalIdentifier:siteExternalIdentifier animationType:animationType completion:^(NSString *error) {
+    callback(@[error]);
+  }];
+}
+
+RCT_EXPORT_METHOD(showBuilding:(NSString *)siteExternalIdentifier buildingExternalIdentifier: (NSString *)buildingExternalIdentifier animationType:(int)animationType callback:(RCTResponseSenderBlock)callback) {
+  [PointrApp.sharedApp showBuildingWithSiteExternalIdentifier:siteExternalIdentifier buildingExternalIdentifier:buildingExternalIdentifier animationType:animationType completion:^(NSString *error) {
+    callback(@[error]);
+  }];
+}
+
+RCT_EXPORT_METHOD(showLevel:(NSString *)siteExternalIdentifier buildingExternalIdentifier: (NSString *)buildingExternalIdentifier levelIndex:(int)levelIndex animationType:(int)animationType callback:(RCTResponseSenderBlock)callback) {
+  [PointrApp.sharedApp showLevelWithSiteExternalIdentifier:siteExternalIdentifier buildingExternalIdentifier:buildingExternalIdentifier levelIndex:levelIndex animationType:animationType completion:^(NSString *error) {
+    callback(@[error]);
+  }];
+}
+
+RCT_EXPORT_METHOD(showPoiDetails:(NSString *)siteExternalIdentifier poiExternalIdentifier: (NSString *)poiExternalIdentifier animationType:(int)animationType callback:(RCTResponseSenderBlock)callback) {
+  [PointrApp.sharedApp showPoiDetailsWithSiteExternalIdentifier:siteExternalIdentifier poiExternalIdentifier:poiExternalIdentifier animationType:animationType completion:^(NSString *error) {
+    callback(@[error]);
+  }];
+}
+
+RCT_EXPORT_METHOD(showPathFindingToPoi:(NSString *)siteExternalIdentifier poiExternalIdentifier: (NSString *)poiExternalIdentifier animationType:(int)animationType callback:(RCTResponseSenderBlock)callback) {
+  [PointrApp.sharedApp showPathFindingToPoiWithSiteExternalIdentifier:siteExternalIdentifier poiExternalIdentifier:poiExternalIdentifier animationType:animationType completion:^(NSString *error) {
+    callback(@[error]);
+  }];
+}
+
+RCT_EXPORT_METHOD(showPathFindingBetweenPOIs:(NSString *)siteExternalIdentifier sourcePoiExternalIdentifier: (NSString *)sourcePoiExternalIdentifier destinationPoiExternalIdentifier: (NSString *)destinationPoiExternalIdentifier animationType:(int)animationType callback:(RCTResponseSenderBlock)callback) {
+  [PointrApp.sharedApp showPathFindingBetweenPOIsWithSiteExternalIdentifier:siteExternalIdentifier sourcePoiExternalIdentifier:sourcePoiExternalIdentifier destinationPoiExternalIdentifier:destinationPoiExternalIdentifier animationType:animationType completion:^(NSString *error) {
+    if (error) {
+      callback(@[error]);
+      return;
+    }
+    callback(@[]);
+  }];
+}
+
+RCT_EXPORT_METHOD(getCurrentLocation:(RCTResponseSenderBlock)callback) {
+  [PointrApp.sharedApp getCurrentLocationWithCompletion:^(NSDictionary *location, NSString *error) {
+    if (error != nil) {
+      callback(@[error]);
+    } else {
+      if ([location count] > 0 && [[location objectForKey:@"latitude"] integerValue] != -999999) {
+        callback(@[location]);
+      } else {
+        callback(@[@"There is no location"]);
+      }
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setPointrMapWidgetConfiguration:(NSString *)string) {
+  [PointrApp.sharedApp setPointrMapWidgetConfigurationWithString:string];
+}
+
+#pragma mark Event Manager Delegate
+
+- (void)onPositionManagerCalculatedLocationWithLocation:(NSDictionary<NSString *,id> * _Nonnull)location {
+  if (!hasListeners) return;
+  [self sendEventWithName:@"OnPositionManagerCalculatedLocation" body:location];
+}
+
+- (void)onBuildingClicked:(NSDictionary<NSString *,id> * _Nonnull)building { 
+  if (!hasListeners) return;
+  [self sendEventWithName:@"OnBuildingClicked" body:building];
+}
+
+
+- (void)onSiteClicked:(NSDictionary<NSString *,id> * _Nonnull)site { 
+  if (!hasListeners) return;
+  [self sendEventWithName:@"OnSiteClicked" body:site];
+}
+
+@end