react-native-pointr 0.0.0 → 8.14.3

package/ios/PointrApp.swift

@@ -21,6 +21,8 @@ import PointrKit
     
     @objc public static let sharedApp = PointrApp()
     
+    @objc public static var shouldRequestPermissionsAtStartup: Bool = true
+    
     let params = PTRParams()
     
     let dispatchGroup = DispatchGroup()
@@ -29,7 +31,6 @@ import PointrKit
     
     var configuration: Dictionary<String,Any>? = nil
     
-    private var mapDispatchGroupDataManager = [Int32: [DispatchGroup]]()
     private var dispatchGroupSiteManager = [DispatchGroup]()
     
     var rootViewController: UIViewController? = nil
@@ -78,10 +79,10 @@ import PointrKit
     }
     
     func initialize(licenseKey: String, baseUrl: String, clientIdentifier: String, environment: String = "prod", logLevel: Int = 4, rootViewController: UIViewController) {
+        Pointr.shared.permissionManager?.delegate = self
         self.rootViewController = rootViewController
-        self.params.mode = PointrDebugMode()
+        self.params.mode = PointrReleaseMode()
         // 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
@@ -172,6 +173,18 @@ import PointrKit
         Pointr.shared.stop()
     }
     
+    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()
+            }
+        }
+    }
+    
     func showSite(siteExternalIdentifier id: String, animationType:Int, completion: @escaping (String?) -> Void) {
         func showSiteWithCompletion(completion: @escaping (String?) -> Void) {
             self.initializeMapWidget()
@@ -307,7 +320,7 @@ import PointrKit
                 return
             }
             
-            if !self.loadData(for: site, dataManager: dataManager) {
+            if !self.loadData(for: site) {
                 completion("Data are not ready for site: \(siteExternalIdentifier)")
                 return
             }
@@ -351,9 +364,7 @@ import PointrKit
     }
     
     func getSite(with siteExternalIdentifier: String, siteManager: PTRSiteManagerInterface, timeoutInSeconds: Int = 15) -> PTRSite? {
-        if let site = siteManager.site(withExternalIdentifier: siteExternalIdentifier) {
-            return site
-        } else {
+        if siteManager.sites().isEmpty {
             let dispatchGroup = DispatchGroup()
             self.dispatchGroupSiteManager.append(dispatchGroup)
             dispatchGroup.enter()
@@ -364,19 +375,26 @@ import PointrKit
         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()
+    func loadData(for site: PTRSite, timeoutInSeconds: Int = 15) -> Bool {
+        guard let poiManager = Pointr.shared.poiManager else { return false }
+        guard !poiManager.hasContent(for: site) else { return true }
+        guard let dataManager = Pointr.shared.dataManager else { return false }
+        let listener = DataManagerListener(site: site)
+        dataManager.addListener(listener)
         dataManager.loadData(forSite: site.internalIdentifier, shouldRespectCachePolicy: false)
-        _ = dispatchGroup.wait(wallTimeout: .now() + DispatchTimeInterval.seconds(timeoutInSeconds))
-        dataManager.removeListener(self)
-        return dataManager.isContentReady(forSite: site.internalIdentifier)
+        listener.wait(timeoutInSeconds)
+        dataManager.removeListener(listener)
+        return poiManager.hasContent(for: site)
+    }
+    
+    func waitForThemeManager(timeoutInSeconds: Int = 5) {
+        let themeManager = PTRMapWidgetThemeManager()
+        let listener = ThemeManagerListener()
+        themeManager.addListener(listener)
+        if (!themeManager.isConfigurationReady) {
+            listener.wait(timeoutInSeconds)
+        }
+        themeManager.removeListener(listener)
     }
     
     func getAnimationTypeFromInt(value: Int) -> PTRMapAnimationType {
@@ -393,6 +411,7 @@ import PointrKit
     
     func initializeMapWidget() {
         if self.viewController != nil { return }
+        waitForThemeManager()
         self.viewController = PTRMapWidgetViewController(configuration: getMapWidgetConfiguration())
         self.viewController?.exitButton?.addListener(self)
         self.viewController?.mapViewController.addListener(self)
@@ -560,22 +579,64 @@ extension PointrApp: PTRSiteManagerDelegate {
     }
 }
 
-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
     }
 }
+
+extension PointrApp: PTRPermissionManagerDelegate {
+    public func permissionManagerShouldRequestBluetoothServicesPermission(_ permissionManager: PTRPermissionManager) -> Bool {
+        return PointrApp.shouldRequestPermissionsAtStartup
+    }
+    public func permissionManagerShouldRequestBluetoothAuthorizationPermission(_ permissionManager: PTRPermissionManager) -> Bool {
+        return PointrApp.shouldRequestPermissionsAtStartup
+    }
+    public func permissionManagerShouldRequestCoreMotionAuthorizationPermission(_ permissionManager: PTRPermissionManager) -> Bool {
+        return PointrApp.shouldRequestPermissionsAtStartup
+    }
+    public func permissionManagerShouldRequestLocationAuthorizationPermissionForWhenInUse(_ permissionManager: PTRPermissionManager) -> Bool {
+        return PointrApp.shouldRequestPermissionsAtStartup
+    }
+    public func permissionManagerShouldRequestLocationAuthorizationPermissionForAlways(_ permissionManager: PTRPermissionManager) -> Bool {
+        return PointrApp.shouldRequestPermissionsAtStartup
+    }
+    public func permissionManagerShouldRequestUserNotificationAuthorizationPermission(_ permissionManager: PTRPermissionManager) -> Bool {
+        return PointrApp.shouldRequestPermissionsAtStartup
+    }
+}
+
+class DataManagerListener: NSObject, PTRDataManagerDelegate {
+    let dispatchGroup = DispatchGroup()
+    let site: PTRSite
+    init(site: PTRSite) {
+        self.site = site
+        super.init()
+        dispatchGroup.enter()
+    }
+    func onDataManagerCompleteAll(for site: PTRSite, isSuccessful: Bool, dataFromOnline isOnlineData: Bool, errorMessages: [NSNumber : String]) {
+        guard isOnlineData else {return}
+        dispatchGroup.leave()
+    }
+    func wait(_ seconds: Int = 15) {
+        _ = dispatchGroup.wait(wallTimeout: .now() + DispatchTimeInterval.seconds(seconds))
+    }
+}
+
+class ThemeManagerListener: NSObject, PTRMapWidgetThemeManagerListener {
+    let dispatchGroup = DispatchGroup()
+    
+    override init() {
+        super.init()
+        dispatchGroup.enter()
+    }
+    
+    func themeManagerConfigurationReady() {
+        dispatchGroup.leave()
+    }
+    
+    func wait(_ seconds: Int = 5) {
+        _ = dispatchGroup.wait(wallTimeout: .now() + DispatchTimeInterval.seconds(seconds))
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-pointr",
-  "version": "0.0.0",
+  "version": "8.14.3",
   "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.13.0"
+  s.dependency "PointrKit", "~> 8"
 
   # 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

@@ -0,0 +1,79 @@
+/**
+ * Command types supported by the Pointr SDK
+ */
+export enum PTRCommandType {
+    SITE = "site",
+    BUILDING = "building",
+    LEVEL = "level",
+    POI = "poi",
+    PATH = "path",
+    STATIC_PATH = "staticPath"
+}
+/**
+ * Base class for all Pointr SDK commands
+ * @param type - the command type
+ */
+export abstract class PTRCommand {
+    constructor(public type: PTRCommandType = PTRCommandType.SITE) { }
+}
+/**
+ * Command to show a site
+ * @param site - the site to show
+ */
+export class PTRSiteCommand extends PTRCommand {
+    constructor(public site: string) {
+        super(PTRCommandType.SITE);
+    }
+}
+/**
+ * Command to show a building
+ * @param site - the site to show
+ * @param building - the building to show
+ */
+export class PTRBuildingCommand extends PTRCommand {
+    constructor(public site: string, public building: string) {
+        super(PTRCommandType.BUILDING);
+    }
+}
+/**
+ * Command to show a level
+ * @param site - the site to show
+ * @param building - the building to show
+ * @param level - the level to show
+ */
+export class PTRLevelCommand extends PTRCommand {
+    constructor(public site: string, public building: string, public level: number) {
+        super(PTRCommandType.LEVEL);
+    }
+}
+/**
+ * Command to show a POI
+ * @param site - the site that has the POI
+ * @param poi - the POI to show
+ */
+export class PTRPoiCommand extends PTRCommand {
+    constructor(public site: string, public poi: string) {
+        super(PTRCommandType.POI);
+    }
+}
+/**
+ * Command to show a path
+ * @param site - the site that has the POI
+ * @param poi - the POI to show the path to from the current location
+ */
+export class PTRPathCommand extends PTRCommand {
+    constructor(public site: string, public poi: string) {
+        super(PTRCommandType.PATH);
+    }
+}
+/**
+ * Command to show a static path
+ * @param site - the site that has the POIs
+ * @param fromPoi - the POI to start the path from
+ * @param toPoi - the POI to end the path at
+ */
+export class PTRStaticPathCommand extends PTRCommand {
+    constructor(public site: string, public fromPoi: string, public toPoi: string) {
+        super(PTRCommandType.STATIC_PATH);
+    }
+}

package/src/PTRMapWidgetUtils.ts

@@ -0,0 +1,66 @@
+import { UIManager } from 'react-native';
+import { PTRSiteCommand, PTRBuildingCommand, PTRLevelCommand, PTRPoiCommand, PTRPathCommand, PTRStaticPathCommand, PTRCommand, PTRCommandType } from 'react-native-pointr/src/PTRCommand';
+/**
+ * Show the map widget with the given command
+ * @param reactTag view tag of the map widget
+ * @param ptrCommand command to show the map widget
+ */
+export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
+  console.log(`Showing map widget with command: ${ptrCommand.type}`);
+  switch (ptrCommand.type) {
+    case PTRCommandType.SITE: {
+      const siteCommand = ptrCommand as PTRSiteCommand;
+      UIManager.dispatchViewManagerCommand(
+        reactTag,
+        ptrCommand.type,
+        [siteCommand.site],
+      );
+      break;
+    }
+    case PTRCommandType.BUILDING: {
+      const buildingCommand = ptrCommand as PTRBuildingCommand;
+      UIManager.dispatchViewManagerCommand(
+        reactTag,
+        ptrCommand.type,
+        [buildingCommand.site, buildingCommand.building],
+      );
+      break;
+    }
+    case PTRCommandType.LEVEL: {
+      const levelCommand = ptrCommand as PTRLevelCommand;
+      UIManager.dispatchViewManagerCommand(
+        reactTag,
+        ptrCommand.type,
+        [levelCommand.site, levelCommand.building, levelCommand.level],
+      );
+      break;
+    }
+    case PTRCommandType.POI: {
+      const poiCommand = ptrCommand as PTRPoiCommand;
+      UIManager.dispatchViewManagerCommand(
+        reactTag,
+        ptrCommand.type,
+        [poiCommand.site, poiCommand.poi],
+      );
+      break;
+    }
+    case PTRCommandType.PATH: {
+      const pathCommand = ptrCommand as PTRPathCommand;
+      UIManager.dispatchViewManagerCommand(
+        reactTag,
+        ptrCommand.type,
+        [pathCommand.site, pathCommand.poi],
+      );
+      break;
+    }
+    case PTRCommandType.STATIC_PATH: {
+      const staticPathCommand = ptrCommand as PTRStaticPathCommand;
+      UIManager.dispatchViewManagerCommand(
+        reactTag,
+        ptrCommand.type,
+        [staticPathCommand.site, staticPathCommand.fromPoi, staticPathCommand.toPoi],
+      );
+      break;
+    }
+  }
+}