react-native-pointr 0.0.0

package/ios/PointrApp.swift

@@ -0,0 +1,581 @@
+//
+//  PointrApp.swift
+//  Pods-PointrSample
+//
+//  Created by Furkan Erdem Perşembe on 15.04.2020.
+//
+
+import UIKit
+import PointrKit
+
+@objc public protocol PTREventManagerDelegate {
+    func onPositionManagerCalculatedLocation(location: [String: Any])
+    func onBuildingClicked(_ building: [String: Any])
+    func onSiteClicked(_ site: [String: Any])
+}
+
+// Class responsible of bridging UI and Pointr SDK with outside world. This class is being used by PTRNativeLibrary.
+@objc public class PointrApp: NSObject {
+    
+    @objc public weak var eventManagerDelegate: PTREventManagerDelegate?
+    
+    @objc public static let sharedApp = PointrApp()
+    
+    let params = PTRParams()
+    
+    let dispatchGroup = DispatchGroup()
+    
+    var viewController: PTRMapWidgetViewController? = nil
+    
+    var configuration: Dictionary<String,Any>? = nil
+    
+    private var mapDispatchGroupDataManager = [Int32: [DispatchGroup]]()
+    private var dispatchGroupSiteManager = [DispatchGroup]()
+    
+    var rootViewController: UIViewController? = nil
+    
+    // TODO: remove the code below when we have widget configuration to remove pathFindingViewController
+    var isRouteFooterViewEnabled = true
+    
+    private override init () {
+        super.init()
+    }
+}
+
+// MARK: - PTRNativeLibrary methods
+
+@objc public extension PointrApp {
+    
+    
+    func covertToDictionary(_ location: PTRCalculatedLocation) -> [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 initialize(licenseKey: String, baseUrl: String, clientIdentifier: String, environment: String = "prod", logLevel: Int = 4, rootViewController: UIViewController) {
+        self.rootViewController = rootViewController
+        self.params.mode = PointrDebugMode()
+        // No need to set environment
+        // self.params.environment = self.getEnvironmentFromString(env: environment)
+        self.params.loggerLevel = PTRLoggerLevel.init(rawValue: Int32(logLevel)) ?? .error
+        
+        // Enter you license key
+        self.params.licenseKey = licenseKey
+        self.params.baseUrl = baseUrl
+        self.params.clientIdentifier = clientIdentifier
+    }
+    
+    func getEnvironmentFromString(env: String) -> PTREnvironment {
+        if env == "prod" {
+            return .production
+        } else if env == "preprod" {
+            return .preProduction
+        } else if env == "qa" {
+            return .QA
+        } else if env == "dev" {
+            return .development
+        } else {
+            return .production
+        }
+    }
+    
+    func setPointrMapWidgetConfiguration(string: String) {
+        guard let data = string.data(using: .utf8) else {
+            Ploge("String does not have valid data")
+            return
+        }
+        do {
+            guard let jsonObject = try JSONSerialization.jsonObject(with: data) as? Dictionary<String,Any> else {
+                Ploge("Bad json")
+                return
+            }
+            configuration = jsonObject
+        } catch let error as NSError {
+            Ploge("Error parsing json: \(string)\n\(error)")
+        }
+    }
+    
+    func getMapWidgetConfiguration() -> PTRMapWidgetConfiguration {
+        let mapWidgetConfiguration = PTRMapWidgetConfiguration.defaultConfiguration()
+        guard let configuration else {
+            return mapWidgetConfiguration
+        }
+        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)
+        }
+        // TODO: remove the code below when we have widget configuration to hide pathFindingViewController
+        // check if navigation footer view needs to be disabled as well.
+        if let isRouteFooterViewEnabled = configuration["isRouteFooterViewEnabled"] as? Bool {
+            self.isRouteFooterViewEnabled = isRouteFooterViewEnabled
+        }
+        // for exit button configuration check for isExitButtonEnabled key to make the api same with android
+        if let value = configuration["isExitButtonShown"] as? Bool {
+            if value {
+                mapWidgetConfiguration.exitButtonConfiguration = PTRMapwidgetExitButtonConfiguration(preferredPosition: .topRight, visibility: .alwaysVisible)
+            } else {
+                mapWidgetConfiguration.exitButtonConfiguration = PTRMapwidgetExitButtonConfiguration(preferredPosition: .topRight, visibility: .notVisible)
+            }
+        } else {
+            mapWidgetConfiguration.exitButtonConfiguration = PTRMapwidgetExitButtonConfiguration(preferredPosition: .topRight, visibility: .automatic)
+        }
+        return mapWidgetConfiguration
+    }
+    
+    func start(completion: @escaping (String) -> Void) {
+        dispatchGroup.enter()
+        Pointr.shared.addListener(self)
+        Pointr.shared.start(with: params) {_ in }
+        dispatchGroup.wait()
+        
+        if Pointr.shared.state == .running {
+            Pointr.shared.positionManager?.addListener(self)
+        }
+        
+        completion(getPointrStateStringFromPointrState(state: Pointr.shared.state))
+    }
+    
+    func stop() {
+        Pointr.shared.positionManager?.removeListener(self)
+        Pointr.shared.stop()
+    }
+    
+    func showSite(siteExternalIdentifier id: String, animationType:Int, completion: @escaping (String?) -> Void) {
+        func showSiteWithCompletion(completion: @escaping (String?) -> Void) {
+            self.initializeMapWidget()
+            self.viewController!.showSite(siteExternalIdentifier: id, animationType: self.getAnimationTypeFromInt(value: animationType)) { error in
+                completion(self.getErrorStringFromMapWidgetError(error: error))
+            }
+            self.presentMapWidgetIfNotPresented()
+        }
+        
+        if Pointr.shared.state != .running {
+            start() { state in
+                if state == "running" {
+                    showSiteWithCompletion(completion: completion)
+                } else {
+                    completion("starting Pointr resulted in \(state) state")
+                }
+            }
+        } else {
+            showSiteWithCompletion(completion: completion)
+        }
+    }
+    
+    func showBuilding(siteExternalIdentifier: String, buildingExternalIdentifier: String, animationType:Int, completion: @escaping (String?) -> Void) {
+        func showBuildingWithCompletion(completion: @escaping (String?) -> Void) {
+            self.initializeMapWidget()
+            self.viewController!.showBuilding(siteExternalIdentifier: siteExternalIdentifier, buildingExternalIdentifier: buildingExternalIdentifier, animationType: self.getAnimationTypeFromInt(value: animationType)) { error in
+                completion(self.getErrorStringFromMapWidgetError(error: error))
+            }
+            self.presentMapWidgetIfNotPresented()
+        }
+        
+        if Pointr.shared.state != .running {
+            start() { state in
+                if state == "running" {
+                    showBuildingWithCompletion(completion: completion)
+                } else {
+                    completion("starting Pointr resulted in \(state) state")
+                }
+            }
+        } else {
+            showBuildingWithCompletion(completion: completion)
+        }
+    }
+    
+    func showLevel(siteExternalIdentifier: String, buildingExternalIdentifier: String, levelIndex: Int, animationType:Int, completion: @escaping (String?) -> Void) {
+        func showLevelWithCompletion(completion: @escaping (String?) -> Void) {
+            self.initializeMapWidget()
+            self.viewController!.showLevel(siteExternalIdentifier: siteExternalIdentifier, buildingExternalIdentifier: buildingExternalIdentifier, levelIndex: levelIndex, animationType: self.getAnimationTypeFromInt(value: animationType)) { error in
+                completion(self.getErrorStringFromMapWidgetError(error: error))
+            }
+            self.presentMapWidgetIfNotPresented()
+        }
+        
+        if Pointr.shared.state != .running {
+            start() { state in
+                if state == "running" {
+                    showLevelWithCompletion(completion: completion)
+                } else {
+                    completion("starting Pointr resulted in \(state) state")
+                }
+            }
+        } else {
+            showLevelWithCompletion(completion: completion)
+        }
+    }
+    
+    func showPoiDetails(siteExternalIdentifier id: String, poiExternalIdentifier: String, animationType:Int, completion: @escaping (String?) -> Void) {
+        func showPoiDetailsWithCompletion(completion: @escaping (String?) -> Void) {
+            self.initializeMapWidget()
+            self.viewController!.showPoiDetails(siteExternalIdentifier: id, poiExternalIdentifier: poiExternalIdentifier, animationType: self.getAnimationTypeFromInt(value: animationType)) { error in
+                completion(self.getErrorStringFromMapWidgetError(error: error))
+            }
+            self.presentMapWidgetIfNotPresented()
+        }
+        
+        if Pointr.shared.state != .running {
+            start() { state in
+                if state == "running" {
+                    showPoiDetailsWithCompletion(completion: completion)
+                } else {
+                    completion("starting Pointr resulted in \(state) state")
+                }
+            }
+        } else {
+            showPoiDetailsWithCompletion(completion: completion)
+        }
+    }
+    
+    func showPathFindingToPoi(siteExternalIdentifier id: String, poiExternalIdentifier: String, animationType:Int, completion: @escaping (String?) -> Void) {
+        func showPathFindingToPoiWithCompletion(completion: @escaping (String?) -> Void) {
+            self.initializeMapWidget()
+            self.viewController!.showPathFinding(siteExternalIdentifier: id, poiExternalIdentifier: poiExternalIdentifier, animationType: self.getAnimationTypeFromInt(value: animationType)) { error in
+                completion(self.getErrorStringFromMapWidgetError(error: error))
+            }
+            self.presentMapWidgetIfNotPresented()
+        }
+        
+        if Pointr.shared.state != .running {
+            start() { state in
+                if state == "running" {
+                    showPathFindingToPoiWithCompletion(completion: completion)
+                } else {
+                    completion("starting Pointr resulted in \(state) state")
+                }
+            }
+        } else {
+            showPathFindingToPoiWithCompletion(completion: completion)
+        }
+    }
+    
+    
+    func showPathFindingBetweenPOIs(siteExternalIdentifier: String, sourcePoiExternalIdentifier: String, destinationPoiExternalIdentifier: String, animationType:Int, completion: @escaping (String?) -> Void) {
+        if Pointr.shared.state != .running {
+            start() { state in
+                if state != "running" {
+                    completion("starting Pointr resulted in \(state) state")
+                    return
+                }
+            }
+        }
+        
+        DispatchQueue.global().async {
+            guard let dataManager = Pointr.shared.dataManager,
+                  let siteManager = Pointr.shared.siteManager,
+                  let poiManager = Pointr.shared.poiManager,
+                  let pathManager = Pointr.shared.pathManager else {
+                completion("Managers are not ready")
+                return
+            }
+            
+            guard let site = self.getSite(with: siteExternalIdentifier, siteManager: siteManager) else {
+                completion("Could not find site \(siteExternalIdentifier)")
+                return
+            }
+            
+            if !self.loadData(for: site, dataManager: dataManager) {
+                completion("Data are not ready for site: \(siteExternalIdentifier)")
+                return
+            }
+            
+            guard let from = poiManager.pois(for: site, withExternalIdentifier: sourcePoiExternalIdentifier) else {
+                completion("Could not find poi: \(sourcePoiExternalIdentifier) within site: \(siteExternalIdentifier)")
+                return
+            }
+            
+            guard let to = poiManager.pois(for: site, withExternalIdentifier: destinationPoiExternalIdentifier) else {
+                completion("Could not find poi: \(destinationPoiExternalIdentifier) within site: \(siteExternalIdentifier)")
+                return
+            }
+            
+            guard let path = pathManager.calculatePath(fromLocation: from.location, toNearestLocationIn: [to.location]) else {
+                completion("Unable to calculate path between locations")
+                return
+            }
+            
+            guard let fromLevel = from.location.level else {
+                completion("Starting poi is not within any level")
+                return
+            }
+            DispatchQueue.main.async {
+                self.initializeMapWidget()
+                self.presentMapWidgetIfNotPresented()
+                self.viewController!.showLevel(fromLevel, animationType: self.getAnimationTypeFromInt(value: animationType)) { error in
+                    if let e = error {
+                        completion(self.getErrorStringFromMapWidgetError(error: e))
+                        return
+                    }
+                    let layer = PTRMapSymbolLayer(identifier: UUID().uuidString)
+                    self.viewController?.mapViewController.addLayer(layer)
+                    self.viewController?.mapViewController.addFeatures([to, from], toLayer: layer.identifier)
+                    self.viewController?.mapViewController.zoomToCoordinate(to.coordinate)
+                    self.viewController?.mapViewController.currentPath = path
+                    completion(nil)
+                }
+            }
+        }
+    }
+    
+    func getSite(with siteExternalIdentifier: String, siteManager: PTRSiteManagerInterface, timeoutInSeconds: Int = 15) -> PTRSite? {
+        if let site = siteManager.site(withExternalIdentifier: siteExternalIdentifier) {
+            return site
+        } else {
+            let dispatchGroup = DispatchGroup()
+            self.dispatchGroupSiteManager.append(dispatchGroup)
+            dispatchGroup.enter()
+            siteManager.addListener(self)
+            _ = dispatchGroup.wait(wallTimeout: .now() + DispatchTimeInterval.seconds(timeoutInSeconds))
+            siteManager.removeListener(self)
+        }
+        return siteManager.site(withExternalIdentifier: siteExternalIdentifier)
+    }
+    
+    func loadData(for site: PTRSite, dataManager: PTRDataManagerInterface, timeoutInSeconds: Int = 30) -> Bool {
+        if(dataManager.isContentReady(forSite: site.internalIdentifier)) {
+            return true
+        }
+        let dispatchGroup = DispatchGroup()
+        self.mapDispatchGroupDataManager[site.internalIdentifier] = self.mapDispatchGroupDataManager[site.internalIdentifier] ?? [DispatchGroup]()
+        self.mapDispatchGroupDataManager[site.internalIdentifier]?.append(dispatchGroup)
+        dataManager.addListener(self)
+        dispatchGroup.enter()
+        dataManager.loadData(forSite: site.internalIdentifier, shouldRespectCachePolicy: false)
+        _ = dispatchGroup.wait(wallTimeout: .now() + DispatchTimeInterval.seconds(timeoutInSeconds))
+        dataManager.removeListener(self)
+        return dataManager.isContentReady(forSite: site.internalIdentifier)
+    }
+    
+    func getAnimationTypeFromInt(value: Int) -> PTRMapAnimationType {
+        if value == 0 {
+            return .none
+        } else if value == 1 {
+            return .standard
+        } else if value == 2  {
+            return .flyOver
+        } else {
+            return .none
+        }
+    }
+    
+    func initializeMapWidget() {
+        if self.viewController != nil { return }
+        self.viewController = PTRMapWidgetViewController(configuration: getMapWidgetConfiguration())
+        self.viewController?.exitButton?.addListener(self)
+        self.viewController?.mapViewController.addListener(self)
+    }
+    
+    func presentMapWidgetIfNotPresented() {
+        guard let viewController = viewController else {
+            return
+        }
+        if viewController.view.window != nil {
+            return
+        }
+        viewController.modalPresentationStyle = .fullScreen
+        rootViewController?.view.addSubview(viewController.view)
+        // rootViewController?.present(viewController, animated: true)
+        // TODO: remove code below when we have widget configuration to hide whole pathFindingViewController
+        viewController.addListener(self)
+    }
+    
+    func getCurrentLocation(completion: @escaping ([String: Any]?, String?) -> Void) {
+        func getLocationWithCompletion(completion: @escaping ([String: Any]?, String?) -> Void) {
+            if let location = Pointr.shared.positionManager?.currentCalculatedLocation {
+                completion(covertToDictionary(location), nil)
+            } else {
+                completion([:], nil)
+            }
+        }
+        
+        if Pointr.shared.state != .running {
+            start() { s in
+                let state = self.getPointrStateFromPointrStateString(string: s)
+                if state == .running {
+                    getLocationWithCompletion(completion: completion)
+                } else {
+                    completion(nil, "starting Pointr resulted in \(state) state")
+                }
+            }
+        } else {
+            getLocationWithCompletion(completion: completion)
+        }
+    }
+    
+    func getErrorStringFromMapWidgetError(error: PTRMapWidgetError?) -> String {
+        guard let error = error else {
+            return ""
+        }
+        switch error.type {
+        case .unknownMapLoading:
+            return "An unknown error occured when loading map"
+        case .invalidMapUrl:
+            return "Map Url is invalid"
+        case .unknownDataLoading:
+            return "An unknown error occured when loading data"
+        case .noSite:
+            return "There is no site with given id"
+        case .noBuilding:
+            return "There is no building with given id"
+        case .noLevel:
+            return "There is no level with given index"
+        case .noPoi:
+            return "There is no poi with given id"
+        case .noPosition:
+            return "Position could not be acquired for path calculation"
+        case .pathManagerTimeout:
+            return "Path manager is not ready for site"
+        case .noPathExist:
+            return "Path does not exist for poi"
+        case .noBuildingBounds:
+            return "No bounds for Building"
+        case .noSiteBounds:
+            return "No bounds for Site"
+        case .invalidCoordinate:
+            return "Invalid coordinate"
+        case .pointrNotRunning:
+            return "Pointr SDK not running when Map Wigdet was initialised"
+        case .noPoiCategory:
+            return "There is no poi category with given title"
+        default:
+            return "An unknown error occured"
+        }
+    }
+    
+    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"
+        case .off:
+            return "off"
+        default:
+            return ""
+        }
+    }
+    
+    func getPointrStateFromPointrStateString(string: String) -> PointrState {
+        switch (string) {
+        case "running":
+            return .running
+        case "failed registration":
+            return .failedRegistration
+        case "failed validation":
+            return .failedValidation
+        case "failed invalid deep link url":
+            return .failedInvalidDeepLinkUrl
+        case "failed no internet":
+            return .failedNoInternet
+        default:
+            return .off
+        }
+    }
+}
+
+extension PointrApp: PTRPositionManagerDelegate {
+    public func onPositionManagerCalculatedLocation(_ calculatedLocation: PTRCalculatedLocation) {
+        eventManagerDelegate?.onPositionManagerCalculatedLocation(location: self.covertToDictionary(calculatedLocation))
+    }
+}
+
+extension PointrApp: PointrStateChangeListener {
+    public func pointrStateDidChange(to state: PointrState) {
+        if state.rawValue <= 0 || state == .running {
+            Pointr.shared.removeListener(self)
+            dispatchGroup.leave()
+        }
+    }
+}
+
+extension PointrApp: PTRExitButtonEventsListener {
+    public func exitButtonDidTap(_ exitbutton: PointrKit.PTRMapWidgetExitButton) {
+        self.viewController?.view.removeFromSuperview()
+        self.viewController = nil
+    }
+}
+
+extension PointrApp: PTRMapEventsListener {
+    public func map(_ map: PTRMapViewController, didReceiveTapOnBuilding building: PTRBuilding) {
+        eventManagerDelegate?.onBuildingClicked([
+            "internalIdentifier": building.internalIdentifier,
+            "externalIdentifier": building.externalIdentifier,
+            "title": building.title
+        ])
+    }
+    public func map(_ map: PTRMapViewController, didReceiveTapOnSite site: PTRSite) {
+        eventManagerDelegate?.onSiteClicked([
+            "internalIdentifier": site.internalIdentifier,
+            "externalIdentifier": site.externalIdentifier,
+            "title": site.title
+        ])
+    }
+}
+
+extension PointrApp: PTRSiteManagerDelegate {
+    public func onSiteManagerDataChanged() {
+        while(!dispatchGroupSiteManager.isEmpty) {
+            let dispatchGroup = dispatchGroupSiteManager.removeLast()
+            dispatchGroup.leave()
+        }
+    }
+}
+
+extension PointrApp: PTRDataManagerDelegate {
+    public func onDataManagerCompleteAll(for site: PTRSite, isSuccessful: Bool, dataFromOnline isOnlineData: Bool, errorMessages: [NSNumber : String]) {
+        if (!isOnlineData) {
+            return
+        }
+        while(self.mapDispatchGroupDataManager[site.internalIdentifier]?.isEmpty == false) {
+            if let dispatchGroup = self.mapDispatchGroupDataManager[site.internalIdentifier]?.removeLast() {
+                dispatchGroup.leave()
+            }
+        }
+    }
+}
+
+// TODO: remove below code when we have parameter to hide whole pathFindingViewController
+extension PointrApp: PTRMapWidgetEventsListener {
+    public func mapWidgetWillPresentPathFinding(_ mapWidget: PTRMapWidgetViewController, pathFinding: PTRPathFindingViewController) {
+        pathFinding.view.isHidden = !isRouteFooterViewEnabled && !mapWidget.configuration.isRouteHeaderViewEnabled
+    }
+}

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

@@ -0,0 +1,6 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "react-native-pointr",
+  "version": "0.0.0",
+  "description": "Pointr React-Native Module",
+  "main": "src/index",
+  "author": " <> ()",
+  "license": "UNLICENSED",
+  "homepage": "#readme",
+  "create-react-native-library": {
+    "type": "module-legacy",
+    "languages": "kotlin-swift",
+    "version": "0.41.0"
+  }
+}

package/react-native-pointr.podspec

@@ -0,0 +1,43 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-pointr"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => ".git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  s.dependency "PointrKit", "8.13.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.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React/Core"
+
+    # Don't install the dependencies when we run `pod install` in the old architecture.
+    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig    = {
+          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+          "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+end

package/src/index.tsx

@@ -0,0 +1,20 @@
+import { NativeModules, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'react-native-pointr' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const PTRNativePointrLibrary = NativeModules.PTRNativePointrLibrary
+  ? NativeModules.PTRNativePointrLibrary
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+module.exports = PTRNativePointrLibrary;