react-native-pointr 8.16.1 → 9.2.0

package/ios/PTRNativeLibrary.swift

@@ -0,0 +1,357 @@
+import Foundation
+import PointrKit
+import React
+
+@objc public protocol PTREventManagerDelegate {
+    func onPositionManagerCalculatedLocation(location: [String: Any])
+    func onBuildingClicked(_ building: [String: Any])
+    func onSiteClicked(_ site: [String: Any])
+}
+
+@objc(PTRNativePointrLibrary)
+class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
+    
+    private var hasListeners = false
+    
+    // PointrApp functionality moved here
+    @objc public weak var eventManagerDelegate: PTREventManagerDelegate?
+    @objc public static var shouldRequestPermissionsAtStartup: Bool = true
+    @objc public static let params = PTRParams()
+    
+    let dispatchGroup = DispatchGroup()
+    var ptrMapWidget: PTRMapWidgetViewController? = nil
+    
+    
+    static var configuration: Dictionary<String,Any>? = nil {
+        didSet {
+            guard let configuration else {
+                return
+            }
+            let mirror = Mirror(reflecting: mapWidgetConfiguration)
+            for attr in mirror.children {
+                guard let key = attr.label else {
+                    continue
+                }
+                // only set boolean values
+                guard let value = configuration[key] as? Bool, attr.value is Bool else {
+                    continue
+                }
+                mapWidgetConfiguration.setValue(value, forKey: key)
+            }
+        }
+    }
+    
+    @objc public
+    static var mapWidgetConfiguration: PTRMapWidgetConfiguration = PTRMapWidgetConfiguration.defaultConfiguration()
+    
+    private var dispatchGroupSiteManager = [DispatchGroup]()
+    var rootViewController: UIViewController? = nil
+    var isRouteFooterViewEnabled = true
+    
+    override init() {
+        super.init()
+        self.eventManagerDelegate = self
+        guard let permissionManager = Pointr.shared.permissionManager else {
+            print("EDIP - Pointr permission manager not available")
+            return
+        }
+        permissionManager.delegate = self
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return ["OnPositionManagerCalculatedLocation", "OnBuildingClicked", "OnSiteClicked"]
+    }
+    
+    override func startObserving() {
+        hasListeners = true
+    }
+    
+    override func stopObserving() {
+        hasListeners = false
+    }
+    
+    // MARK: - Utility Methods (from PointrApp)
+    
+    func covertToDictionary(_ location: PTRCalculatedPosition) -> [String: Any] {
+        var dictionary = [String: Any]()
+        if let siteInternalIdentifier = location.site?.internalIdentifier {
+            dictionary.updateValue(siteInternalIdentifier, forKey: "siteInternalIdentifier")
+        }
+        if let buildingInternalIdentifier = location.building?.internalIdentifier {
+            dictionary.updateValue(buildingInternalIdentifier, forKey: "buildingInternalIdentifier")
+        }
+        if let siteExternalIdentifier = location.site?.externalIdentifier {
+            dictionary.updateValue(siteExternalIdentifier, forKey: "siteExternalIdentifier")
+        }
+        if let buildingExternalIdentifier = location.building?.externalIdentifier {
+            dictionary.updateValue(buildingExternalIdentifier, forKey: "buildingExternalIdentifier")
+        }
+        if let levelIndex = location.level?.index {
+            dictionary.updateValue(levelIndex, forKey: "levelIndex")
+        }
+        if location.coordinate.latitude != CLLocationDegrees(PTRPositioningTypes.invalidFloat()) && location.coordinate.longitude != CLLocationDegrees(PTRPositioningTypes.invalidFloat()) {
+            dictionary.updateValue(location.coordinate.latitude, forKey: "latitude")
+            dictionary.updateValue(location.coordinate.longitude, forKey: "longitude")
+        }
+        if location.accuracy != Double(PTRPositioningTypes.invalidFloat()) {
+            dictionary.updateValue(location.accuracy, forKey: "accuracy")
+        }
+        if (location.headingAccuracyClass == .high) {
+            dictionary.updateValue(location.heading, forKey: "heading")
+        }
+        return dictionary
+    }
+    
+    func getAnimationTypeFromInt(value: Int) -> PTRMapAnimationType {
+        switch value {
+        case 0:
+            return .none
+        case 1:
+            return .standard
+        case 2:
+            return .flyOver
+        default:
+            return .none
+        }
+    }
+    
+    func getErrorStringFromMapWidgetError(error: PTRMapWidgetError?) -> String? {
+        guard let error = error else {
+            return nil
+        }
+        return "\(error.errorCode ?? "")"
+    }
+    
+    func getPointrStateStringFromPointrState(state: PointrState) -> String {
+        switch (state) {
+        case .running:
+            return "running"
+        case .failedRegistration:
+            return "failed registration"
+        case .failedValidation:
+            return "failed validation"
+        case .failedInvalidDeepLinkUrl:
+            return "failed invalid deep link url"
+        case .failedNoInternet:
+            return "failed no internet"
+        default:
+            return "off"
+        }
+    }
+    
+    // MARK: - Core Methods
+    
+    @objc func shouldRequestPermissionsAtStartup(_ shouldRequestPermissionsAtStartup: Bool) {
+        PTRNativeLibrary.shouldRequestPermissionsAtStartup = shouldRequestPermissionsAtStartup
+    }
+    
+    @objc func initialize(_ clientIdentifier: String,
+                          licenseKey: String,
+                          baseUrl: String,
+                         logLevel: Int) {
+        guard let presentedViewController = RCTPresentedViewController() else { return }
+        self.rootViewController = presentedViewController
+        PTRNativeLibrary.params.mode = PointrDebugMode()
+        PTRNativeLibrary.params.loggerLevel = PTRLoggerLevel.init(rawValue: Int32(logLevel)) ?? .error
+        PTRNativeLibrary.params.licenseKey = licenseKey
+        PTRNativeLibrary.params.baseUrl = baseUrl
+        PTRNativeLibrary.params.clientIdentifier = clientIdentifier
+    }
+    
+    @objc func start(_ callback: @escaping RCTResponseSenderBlock) {
+        if Pointr.shared.state == .running {
+            callback(["Pointr is already running"])
+        } else {
+            let dispatchGroup = DispatchGroup()
+            dispatchGroup.enter()
+            Pointr.shared.start(with: PTRNativeLibrary.params) { state in
+                if (state == .running || state.rawValue <= 0) {
+                  dispatchGroup.leave()
+                }
+            }
+            dispatchGroup.wait()
+            if Pointr.shared.state == .running {
+                Pointr.shared.positioningManager?.addListener(self)
+            }
+            callback([getPointrStateStringFromPointrState(state: Pointr.shared.state)])
+        }
+    }
+    
+    @objc func stop() {
+        Pointr.shared.positioningManager?.removeListener(self)
+        Pointr.shared.stop()
+    }
+    
+    @objc func requestPermissions() {
+        guard let permissionManager = Pointr.shared.permissionManager else { return }
+        if (!permissionManager.hasLocationAuthorizationWhenInUseOrAlways) {
+            permissionManager.requestLocationAuthorizationPermissionForWhenInUse()
+        }
+        if #available(iOS 17.4, *) {
+            if (!permissionManager.hasCoreMotionAuthorization) {
+                permissionManager.requestCoreMotionAuthorizationPermission()
+            }
+        }
+    }
+    
+    // MARK: - Map Widget Methods
+    
+    func initializeMapWidget() {
+        if ptrMapWidget == nil {
+            ptrMapWidget = PTRMapWidgetViewController(location: PTRMapWidgetSiteLocation(siteIdentifier: ""), configuration: PTRNativeLibrary.mapWidgetConfiguration)
+        }
+    }
+    
+    func presentMapWidgetIfNotPresented() {
+        guard let ptrMapWidget = ptrMapWidget,
+              let rootViewController = rootViewController else { return }
+        
+        if ptrMapWidget.view.superview == nil {
+            rootViewController.view.addSubview(ptrMapWidget.view)
+            ptrMapWidget.view.translatesAutoresizingMaskIntoConstraints = false
+            NSLayoutConstraint.activate([
+                ptrMapWidget.view.topAnchor.constraint(equalTo: rootViewController.view.safeAreaLayoutGuide.topAnchor),
+                ptrMapWidget.view.leadingAnchor.constraint(equalTo: rootViewController.view.leadingAnchor),
+                ptrMapWidget.view.trailingAnchor.constraint(equalTo: rootViewController.view.trailingAnchor),
+                ptrMapWidget.view.bottomAnchor.constraint(equalTo: rootViewController.view.bottomAnchor)
+            ])
+        }
+    }
+    
+    @objc func getCurrentLocation(_ callback: @escaping RCTResponseSenderBlock) {
+        guard let positionManager = Pointr.shared.positioningManager else {
+            callback(["Position manager not available"])
+            return
+        }
+        
+        if let lastLocation = positionManager.lastValidCalculatedPosition {
+            let locationDict = covertToDictionary(lastLocation)
+            if let latitude = locationDict["latitude"] as? Double, latitude != -999999 {
+                callback([locationDict])
+            } else {
+                callback(["There is no location"])
+            }
+        } else {
+            callback(["There is no location"])
+        }
+    }
+    
+    @objc func setPointrMapWidgetConfiguration(_ string: String) {
+        guard let data = string.data(using: .utf8) else {
+            print("String does not have valid data")
+            return
+        }
+        do {
+            guard let jsonObject = try JSONSerialization.jsonObject(with: data) as? Dictionary<String,Any> else {
+                print("Bad json")
+                return
+            }
+            PTRNativeLibrary.configuration = jsonObject
+        } catch let error as NSError {
+            print("Error parsing json: \(string)\n\(error)")
+        }
+    }
+    
+    @objc func isMyCarMarked(_ callback: @escaping RCTResponseSenderBlock) {
+        let feature = Pointr.shared.getMyCarFeature()
+        if feature == nil {
+            callback(["No saved location"])
+            return
+        }
+        callback([])
+    }
+    
+    // MARK: - Event Manager Delegate
+    
+    func onPositionManagerCalculatedLocation(location: [String : Any]) {
+        guard hasListeners else { return }
+        sendEvent(withName: "OnPositionManagerCalculatedLocation", body: location)
+    }
+    
+    func onBuildingClicked(_ building: [String : Any]) {
+        guard hasListeners else { return }
+        sendEvent(withName: "OnBuildingClicked", body: building)
+    }
+    
+    func onSiteClicked(_ site: [String : Any]) {
+        guard hasListeners else { return }
+        sendEvent(withName: "OnSiteClicked", body: site)
+    }
+}
+
+// MARK: - PTRPositionManagerDelegate
+extension PTRNativeLibrary: PTRPositioningManagerDelegate {
+    func onPositioningManagerCalculatedPosition(_ calculatedPosition: PTRCalculatedPosition) {
+        eventManagerDelegate?.onPositionManagerCalculatedLocation(location: self.covertToDictionary(calculatedPosition))
+    }
+}
+
+// MARK: - PTRExitButtonEventsListener
+extension PTRNativeLibrary: PTRExitButtonEventsListener {
+    func exitButtonDidTap() {
+        self.ptrMapWidget?.view.removeFromSuperview()
+        self.ptrMapWidget = nil
+    }
+}
+
+// MARK: - PTRMapEventsListener
+extension PTRNativeLibrary: PTRMapEventsListener {
+    public func map(_ map: PTRMapViewController, didReceiveTapOnFeature feature: PTRFeature) {
+        // Handle feature tap if needed
+        if (feature.typeCode == "building-outline") {
+            eventManagerDelegate?.onBuildingClicked([
+                "internalIdentifier": feature.identifier,
+                "externalIdentifier": feature.externalIdentifier,
+                "title": feature.name
+            ])
+        } else if (feature.typeCode == "site-outline") {
+            eventManagerDelegate?.onSiteClicked([
+                "internalIdentifier": feature.identifier,
+                "externalIdentifier": feature.externalIdentifier,
+                "title": feature.name
+            ])
+        }
+    }
+}
+
+// MARK: - PTRSiteManagerDelegate
+extension PTRNativeLibrary: PTRSiteManagerDelegate {
+    public func onSiteManagerDataChanged() {
+        while(!dispatchGroupSiteManager.isEmpty) {
+            let dispatchGroup = dispatchGroupSiteManager.removeLast()
+            dispatchGroup.leave()
+        }
+    }
+}
+
+// MARK: - PTRPermissionManagerDelegate
+extension PTRNativeLibrary: PTRPermissionManagerDelegate {
+    public func permissionManagerShouldRequestLocationAuthorizationPermission() -> Bool {
+        Plogv("Should request location permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
+        return PTRNativeLibrary.shouldRequestPermissionsAtStartup
+    }
+    
+    public func permissionManagerShouldRequestBluetoothServicesPermission() -> Bool {
+        Plogv("Should request bluetooth permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
+        return PTRNativeLibrary.shouldRequestPermissionsAtStartup
+    }
+    
+    public func permissionManagerShouldRequestUserNotificationAuthorizationPermission() -> Bool {
+        Plogv("Should request notification permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
+        return PTRNativeLibrary.shouldRequestPermissionsAtStartup
+    }
+    
+    public func permissionManagerShouldRequestCoreMotionAuthorizationPermission(_ permissionManager: any PTRPermissionManagerInterface) -> Bool {
+        Plogv("Should request core motion permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
+        return PTRNativeLibrary.shouldRequestPermissionsAtStartup
+    }
+    
+    func permissionManagerShouldRequestLocationAuthorizationPermissionForWhenInUse(_ permissionManager: any PTRPermissionManagerInterface) -> Bool {
+        Plogv("Should request location when in use permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
+        return PTRNativeLibrary.shouldRequestPermissionsAtStartup
+    }
+}

package/ios/react-native-pointr-Bridging-Header.h

@@ -4,3 +4,8 @@
 
 #import <React/RCTBridgeModule.h>
 #import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUtils.h>
+#import <React/RCTComponent.h>
+#import <PointrKit/PointrKit.h>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-pointr",
-  "version": "8.16.1",
+  "version": "9.2.0",
   "description": "Pointr React-Native Module",
   "main": "src/index",
   "author": " <> ()",

package/react-native-pointr.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
-  s.dependency 'PointrKit', '~> 8'
+  s.dependency 'PointrKit', '9.2.0'
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.

package/src/PTRCommand.ts

@@ -10,7 +10,8 @@ export enum PTRCommandType {
     STATIC_PATH = "staticPath",
     MARK_MY_CAR_LEVEL = "markMyCarForLevel",
     MARK_MY_CAR_SITE = "markMyCarForSite",
-    MY_CAR_SITE = "myCarForSite"
+    SHOW_MY_CAR_SITE = "showMyCarForSite",
+    START_AND_FOCUS = "startAndFocus"
 }
 /**
  * Base class for all Pointr SDK commands
@@ -110,10 +111,30 @@ export class PTRMarkMyCarSiteCommand extends PTRCommand {
 /**
  * Command to show my car details
  * @param site - the site to show my car details
+ * @param shouldShowPopup - flag to show popup or not
  * @param animationType - animation type to show map loading
  */
-export class PTRMyCarSiteCommand extends PTRCommand {
-    constructor(public site: string, public animationType: number = 1) {
-        super(PTRCommandType.MY_CAR_SITE);
+export class PTRShowMyCarSiteCommand extends PTRCommand {
+    constructor(public site: string, public shouldShowPopup: boolean = true, public animationType: number = 1) {
+        super(PTRCommandType.SHOW_MY_CAR_SITE);
     }
+}
+
+/**
+ * Command to start the SDK and focus on a location using an existing PTR command
+ * This command is not a PTRCommand itself, but wraps SDK initialization with a focus command
+ * @param clientId - the client ID for SDK initialization
+ * @param licenseKey - the license key for SDK initialization  
+ * @param baseUrl - the base URL for SDK initialization
+ * @param logLevel - the log level for SDK initialization
+ * @param command - the PTR command to execute after SDK initialization (PTRSiteCommand, PTRBuildingCommand, PTRLevelCommand, or PTRPoiCommand)
+ */
+export class PTRStartAndFocusCommand {
+    constructor(
+        public clientId: string,
+        public licenseKey: string,
+        public baseUrl: string,
+        public logLevel: number = 4,
+        public command: PTRSiteCommand | PTRBuildingCommand | PTRLevelCommand | PTRPoiCommand
+    ) {}
 }

package/src/PTRMapWidgetUtils.ts

@@ -1,18 +1,109 @@
 import { UIManager } from 'react-native';
-import { PTRSiteCommand, PTRBuildingCommand, PTRLevelCommand, PTRPoiCommand, PTRPathCommand, PTRStaticPathCommand, PTRCommand, PTRCommandType, PTRMarkMyCarLevelCommand, PTRMarkMyCarSiteCommand, PTRMyCarSiteCommand } from 'react-native-pointr/src/PTRCommand';
+import { PTRSiteCommand, PTRBuildingCommand, PTRLevelCommand, PTRPoiCommand, PTRPathCommand, PTRStaticPathCommand, PTRCommand, PTRCommandType, PTRMarkMyCarLevelCommand, PTRMarkMyCarSiteCommand, PTRShowMyCarSiteCommand, PTRStartAndFocusCommand } from 'react-native-pointr/src/PTRCommand';
+/**
+ * Handle PTRStartAndFocusCommand specifically
+ * @param reactTag view tag of the map widget
+ * @param startAndFocusCommand the start and focus command
+ */
+const handleStartAndFocusCommand = (reactTag: number, startAndFocusCommand: PTRStartAndFocusCommand) => {
+  const innerCommand = startAndFocusCommand.command;
+  console.info('Handling PTRStartAndFocusCommand with type:', innerCommand.type);
+  // Build arguments based on the inner command type
+  let args: any[];
+  console.info('Inner command details:', innerCommand);
+  
+  switch (innerCommand.type) {
+    case PTRCommandType.SITE: {
+      const siteCommand = innerCommand as PTRSiteCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        siteCommand.site,
+        "",
+        0
+      ];
+      break;
+    }
+    case PTRCommandType.BUILDING: {
+      const buildingCommand = innerCommand as PTRBuildingCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        buildingCommand.site,
+        buildingCommand.building,
+        0
+      ];
+      break;
+    }
+    case PTRCommandType.LEVEL: {
+      const levelCommand = innerCommand as PTRLevelCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        levelCommand.site,
+        levelCommand.building,
+        levelCommand.level
+      ];
+      break;
+    }
+    case PTRCommandType.POI: {
+      const poiCommand = innerCommand as PTRPoiCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        poiCommand.site,
+        poiCommand.poi,
+        0
+      ];
+      break;
+    }
+    default:
+      console.error('Unsupported command type in PTRStartAndFocusCommand:', innerCommand.type);
+      return;
+  }
+  console.info('Dispatching startAndFocus with args:', args);
+  UIManager.dispatchViewManagerCommand(
+    reactTag,
+    'startAndFocus',
+    args,
+  );
+};
+
 /**
  * Show the map widget with the given command
  * @param reactTag view tag of the map widget
- * @param ptrCommand command to show the map widget
+ * @param ptrCommand command to show the map widget (PTRCommand or PTRStartAndFocusCommand)
  */
-export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
-  console.log(`Showing map widget with command: ${ptrCommand.type}`);
-  switch (ptrCommand.type) {
+export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand | PTRStartAndFocusCommand) => {
+  // Check if it's a PTRStartAndFocusCommand (which doesn't have a 'type' property)
+  if ('command' in ptrCommand) {
+    const startAndFocusCommand = ptrCommand as PTRStartAndFocusCommand;
+    console.log(`Showing map widget with start and focus command: ${startAndFocusCommand.command.type} and reactTag: ${reactTag}`);
+    handleStartAndFocusCommand(reactTag, startAndFocusCommand);
+    return;
+  }
+
+  // Handle regular PTRCommand
+  const command = ptrCommand as PTRCommand;
+  console.log(`Showing map widget with command: ${command.type} and reactTag: ${reactTag}`);
+  switch (command.type) {
     case PTRCommandType.SITE: {
       const siteCommand = ptrCommand as PTRSiteCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'site',
         [siteCommand.site],
       );
       break;
@@ -21,7 +112,7 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       const buildingCommand = ptrCommand as PTRBuildingCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'building',
         [buildingCommand.site, buildingCommand.building],
       );
       break;
@@ -30,7 +121,7 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       const levelCommand = ptrCommand as PTRLevelCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'level',
         [levelCommand.site, levelCommand.building, levelCommand.level],
       );
       break;
@@ -39,7 +130,7 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       const poiCommand = ptrCommand as PTRPoiCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'poi',
         [poiCommand.site, poiCommand.poi],
       );
       break;
@@ -48,7 +139,7 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       const pathCommand = ptrCommand as PTRPathCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'path',
         [pathCommand.site, pathCommand.poi],
       );
       break;
@@ -57,7 +148,7 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       const staticPathCommand = ptrCommand as PTRStaticPathCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'staticPath',
         [staticPathCommand.site, staticPathCommand.fromPoi, staticPathCommand.toPoi],
       );
       break;
@@ -66,7 +157,7 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       const markMyCarCommand = ptrCommand as PTRMarkMyCarLevelCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'markMyCarForLevel',
         [markMyCarCommand.site, markMyCarCommand.building, markMyCarCommand.level, markMyCarCommand.shouldShowPopup, markMyCarCommand.animationType],
       );
       break;
@@ -75,16 +166,16 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       const markMyCarCommand = ptrCommand as PTRMarkMyCarSiteCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'markMyCarForSite',
         [markMyCarCommand.site, markMyCarCommand.shouldShowPopup, markMyCarCommand.animationType],
       );
       break;
     }
-    case PTRCommandType.MY_CAR_SITE: {
-      const myCarCommand = ptrCommand as PTRMyCarSiteCommand;
+    case PTRCommandType.SHOW_MY_CAR_SITE: {
+      const myCarCommand = ptrCommand as PTRShowMyCarSiteCommand;
       UIManager.dispatchViewManagerCommand(
         reactTag,
-        ptrCommand.type,
+        'myCarForSite',
         [myCarCommand.site, myCarCommand.animationType],
       );
       break;

package/android/.settings/org.eclipse.buildship.core.prefs

@@ -1,2 +0,0 @@
-connection.project.dir=../../../android
-eclipse.preferences.version=1

package/android/src/main/AndroidManifest.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.pointr">
-    <application>
-        <activity
-            android:name="com.pointr.PointrMapWidgetActivity"
-            android:exported="true"
-            android:launchMode="singleTask"
-            android:screenOrientation="portrait">
-        </activity>
-    </application>
-</manifest>