@woosmap/react-native-plugin-geofencing 1.0.0-beta.2 → 1.0.0

package/ios/WoosmapGeofencingTurbo.swift

@@ -1,22 +1,71 @@
 import CoreLocation
 import WoosmapGeofencing
 
-/// TurboModule implementation for the region-CRUD + key/radius slice migrated
-/// This is a thin adapter over the shared
-/// `WoosmapGeofenceService` — the same service the legacy `PluginGeofencing`
-/// module talks to — so the two modules stay independent without duplicating
-/// business logic.
+/// TurboModule implementation — Approach B: extends RCTEventEmitter so it can
+/// both expose native methods and fire JS events (geolocationDidChange, etc.).
 ///
 /// The Objective-C++ bridge in `WoosmapGeofencingTurbo.mm` exposes these
 /// methods to the generated `RCTNativeWoosmapGeofencingTurboSpec` protocol and
 /// vends the JSI TurboModule.
 @objc(WoosmapGeofencingTurbo)
-class WoosmapGeofencingTurbo: NSObject {
+class WoosmapGeofencingTurbo: RCTEventEmitter {
 
-  @objc static func requiresMainQueueSetup() -> Bool {
+  /// Location manager used solely to request permissions.
+  private var templocationChecker: CLLocationManager!
+
+  /// Active location watch IDs keyed by watch-id string.
+  private var locationWatchStack: [String: String] = [:]
+
+  /// Active region watch IDs keyed by watch-id string.
+  private var regionWatchStack: [String: String] = [:]
+
+  /// Resolver for an in-flight `requestPermissions` call that is waiting for the
+  /// user to answer the system location dialog. Settled in
+  /// `locationManagerDidChangeAuthorization(_:)` once the OS reports the choice.
+  private var permissionResolve: RCTPromiseResolveBlock?
+
+  /// Forces the module to be initialised on the main queue.
+  /// - Returns: `true` so UIKit / CoreLocation calls are safe at setup.
+  @objc override static func requiresMainQueueSetup() -> Bool {
     return true
   }
 
+  // MARK: - RCTEventEmitter
+
+  /// Creates the module and configures the permission-checking location manager.
+  override init() {
+    super.init()
+    templocationChecker = CLLocationManager()
+    templocationChecker.delegate = self
+    templocationChecker.desiredAccuracy = kCLLocationAccuracyBest
+    locationWatchStack = [:]
+    regionWatchStack = [:]
+  }
+
+  /// The set of event names this emitter can dispatch to JS.
+  /// - Returns: The supported `geolocation` / `woosmapgeofenceRegion` event names.
+  override func supportedEvents() -> [String]! {
+    return ["geolocationDidChange", "geolocationError",
+            "woosmapgeofenceRegionDidChange", "woosmapgeofenceRegionError"]
+  }
+
+  /// Registers a JS listener for the given event. Required stub so the
+  /// TurboModule codegen emits the correct selector.
+  /// - Parameter eventName: The event the JS side is subscribing to.
+  @objc(addListener:)
+  override func addListener(_ eventName: String) { super.addListener(eventName) }
+
+  /// Removes JS listeners. Required stub so the TurboModule codegen emits the
+  /// correct selector.
+  /// - Parameter count: The number of listeners to remove.
+  @objc(removeListeners:)
+  override func removeListeners(_ count: Double) { super.removeListeners(count) }
+
+  // MARK: - Private helpers
+
+  /// Builds an `NSError` in the plugin's error domain.
+  /// - Parameter msg: The localized description for the error.
+  /// - Returns: An `NSError` carrying `msg` under `NSLocalizedDescriptionKey`.
   private func woosmapError(_ msg: String) -> NSError {
     return NSError(
       domain: WoosmapGeofenceMessage.plugin_errorDomain,
@@ -25,6 +74,11 @@ class WoosmapGeofencingTurbo: NSObject {
     )
   }
 
+  // MARK: - Formatters
+
+  /// Maps a native `Region` into the lower-cased dictionary shape the JS facade expects.
+  /// - Parameter woosdata: The region to serialize.
+  /// - Returns: A dictionary mirroring the `RegionRecord` spec type.
   private func formatRegionData(woosdata: Region) -> [AnyHashable: Any] {
     var result: [AnyHashable: Any] = [:]
     result["date"] = woosdata.date.timeIntervalSince1970 * 1000
@@ -39,6 +93,377 @@ class WoosmapGeofencingTurbo: NSObject {
     return result
   }
 
+  /// Maps a native `Location` into the dictionary shape the JS facade expects.
+  /// - Parameter woosdata: The location to serialize.
+  /// - Returns: A dictionary with the location's date/coordinates/identifier.
+  private func formatLocationData(woosdata: Location) -> [AnyHashable: Any] {
+    var result: [AnyHashable: Any] = [:]
+    if let date = woosdata.date {
+      result["date"] = date.timeIntervalSince1970 * 1000
+    } else {
+      result["date"] = 0
+    }
+    result["latitude"] = woosdata.latitude
+    result["locationdescription"] = woosdata.locationDescription
+    result["locationid"] = woosdata.locationId
+    result["longitude"] = woosdata.longitude
+    return result
+  }
+
+  /// Maps a native `POI` into the dictionary shape the JS facade expects.
+  /// - Parameter woosdata: The POI to serialize.
+  /// - Returns: A dictionary with the POI's metadata, coordinates and user properties.
+  private func formatPOIData(woosdata: POI) -> [AnyHashable: Any] {
+    var result: [AnyHashable: Any] = [:]
+    if let data = woosdata.jsonData {
+      do {
+        let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
+        result["jsondata"] = json
+      } catch { }
+    }
+    result["city"] = woosdata.city
+    result["idstore"] = woosdata.idstore
+    result["name"] = woosdata.name
+    if let date = woosdata.date {
+      result["date"] = date.timeIntervalSince1970 * 1000
+    } else {
+      result["date"] = 0
+    }
+    result["distance"] = woosdata.distance
+    result["duration"] = woosdata.duration ?? "-"
+    result["latitude"] = woosdata.latitude
+    result["locationid"] = woosdata.locationId
+    result["longitude"] = woosdata.longitude
+    result["zipcode"] = woosdata.zipCode
+    result["radius"] = woosdata.radius
+    result["address"] = woosdata.address
+    result["countrycode"] = woosdata.countryCode
+    result["tags"] = woosdata.tags
+    result["types"] = woosdata.types
+    result["contact"] = woosdata.contact
+    result["userProperties"] = woosdata.user_properties
+    result["openNow"] = woosdata.openNow
+    return result
+  }
+
+  /// Maps a native `IndoorBeacon` into the dictionary shape the JS facade expects.
+  /// - Parameter woosdata: The indoor beacon to serialize.
+  /// - Returns: A dictionary with the beacon's identifiers, coordinates and properties.
+  private func formatIndoorBeaconData(woosdata: IndoorBeacon) -> [AnyHashable: Any] {
+    var result: [AnyHashable: Any] = [:]
+    result["identifier"] = woosdata.identifier
+    result["properties"] = woosdata.properties
+    result["latitude"] = woosdata.latitude
+    result["longitude"] = woosdata.longitude
+    result["venueId"] = woosdata.venue_id
+    result["major"] = woosdata.Major
+    result["minor"] = woosdata.Minor
+    result["beaconId"] = woosdata.BeaconID
+    result["date"] = woosdata.date.timeIntervalSince1970 * 1000
+    return result
+  }
+
+  // MARK: - Initialize
+
+  /// Initializes the Woosmap geofencing service with the supplied options
+  /// (Woosmap key, tracking profile, protected-region slot, Airship flag).
+  /// - Parameters:
+  ///   - command: A dictionary of initialization options.
+  ///   - resolve: Promise resolver invoked on success.
+  ///   - reject: Promise rejecter invoked on invalid options or failure.
+  @objc(initialize:resolve:reject:)
+  func initialize(command: NSDictionary, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let initParameters = command as? [String: Any] else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.plugin_parsingFailed,
+             woosmapError(WoosmapGeofenceMessage.plugin_parsingFailed))
+      return
+    }
+    var isCallUnsuccessful = false
+    var privateKeyWoosmapAPI = ""
+    var isAirshipCallbackEnable: Bool = false
+    var protectedRegionSlot: Int = -1
+
+    if let keyProtectedRegionSlot = initParameters["protectedRegionSlot"] as? Int {
+      if keyProtectedRegionSlot > 3 {
+        isCallUnsuccessful = true
+        reject(WoosmapGeofenceMessage.plugin_errorDomain,
+               WoosmapGeofenceMessage.invalidProtectedRegionSlot,
+               woosmapError(WoosmapGeofenceMessage.invalidProtectedRegionSlot))
+      } else {
+        protectedRegionSlot = keyProtectedRegionSlot
+      }
+    }
+
+    if let keyWoosmapAPI = initParameters["privateKeyWoosmapAPI"] as? String {
+      privateKeyWoosmapAPI = keyWoosmapAPI
+    }
+#if canImport(AirshipKit)
+    if let keyAirshipPush = initParameters["enableAirshipConnector"] as? Bool {
+      isAirshipCallbackEnable = keyAirshipPush
+    }
+#endif
+
+    if let trackingProfile = initParameters["trackingProfile"] as? String {
+      if ConfigurationProfile(rawValue: trackingProfile) != nil {
+        WoosmapGeofenceService.setup(woosmapKey: privateKeyWoosmapAPI,
+                                     configurationProfile: trackingProfile,
+                                     airshipTrackingEnable: isAirshipCallbackEnable,
+                                     protectedRegionSlot: protectedRegionSlot)
+      } else {
+        isCallUnsuccessful = true
+        reject(WoosmapGeofenceMessage.plugin_errorDomain,
+               WoosmapGeofenceMessage.invalidProfile,
+               woosmapError(WoosmapGeofenceMessage.invalidProfile))
+      }
+    } else {
+      WoosmapGeofenceService.setup(woosmapKey: privateKeyWoosmapAPI,
+                                   configurationProfile: "",
+                                   airshipTrackingEnable: isAirshipCallbackEnable,
+                                   protectedRegionSlot: protectedRegionSlot)
+    }
+    if isCallUnsuccessful == false {
+      resolve(WoosmapGeofenceMessage.initialize)
+    }
+  }
+
+  // MARK: - Permission requests
+
+  /// Requests location permission from the user, presenting a settings prompt
+  /// when the permission has already been decided.
+  /// - Parameters:
+  ///   - background: Pass `true` for always-on access, `false` for when-in-use access.
+  ///   - resolve: Promise resolver invoked with the permission-flow status.
+  ///   - reject: Promise rejecter invoked on failure.
+  @objc(requestPermissions:resolve:reject:)
+  func requestPermissions(background: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    // CLLocationManager must be created/messaged on the main thread; bridge
+    // methods otherwise run on a background queue. Hop to main before touching it.
+    DispatchQueue.main.async {
+      self.performRequestPermissions(background: background, resolve: resolve, reject: reject)
+    }
+  }
+
+  /// Main-thread body of `requestPermissions`. See that method for parameter docs.
+  private func performRequestPermissions(background: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    // A request is already awaiting the OS dialog: reject this new call rather
+    // than overwriting (and leaking) the in-flight promise.
+    if permissionResolve != nil {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.permissionRequestInProgress,
+             woosmapError(WoosmapGeofenceMessage.permissionRequestInProgress))
+      return
+    }
+    let status = CLLocationManager().authorizationStatus
+
+    if background {
+      if status == .notDetermined {
+        // Fresh install: defer the promise until the OS reports the user's
+        // choice via locationManagerDidChangeAuthorization(_:). Not settling
+        // here would hang the JS caller forever.
+        permissionResolve = resolve
+        self.templocationChecker.requestAlwaysAuthorization()
+      } else if status == .authorizedAlways {
+        resolve(WoosmapGeofenceMessage.samePermission)
+      } else {
+        resolve(WoosmapGeofenceMessage.showingPermissionBox)
+        Task { @MainActor in
+          let appname: String = Bundle.main.infoDictionary?[kCFBundleNameKey as String] as? String ?? ""
+          var alertInfo: String = ""
+          if status == .denied {
+            alertInfo = String(format: WoosmapGeofenceMessage.deniedPermission, appname)
+          } else {
+            alertInfo = String(format: WoosmapGeofenceMessage.replacePermission, appname)
+          }
+          let alert = UIAlertController(title: "", message: alertInfo, preferredStyle: UIAlertController.Style.alert)
+          alert.addAction(UIAlertAction(title: WoosmapGeofenceMessage.cancel, style: UIAlertAction.Style.default, handler: nil))
+          alert.addAction(UIAlertAction(title: WoosmapGeofenceMessage.setting, style: UIAlertAction.Style.default, handler: { _ in
+            if let settingsUrl = URL(string: UIApplication.openSettingsURLString) {
+              UIApplication.shared.open(settingsUrl, options: [:], completionHandler: nil)
+            }
+          }))
+          var rootViewController = UIApplication.shared.topViewController
+          if let navigationController = rootViewController as? UINavigationController {
+            rootViewController = navigationController.viewControllers.first
+          }
+          if let tabBarController = rootViewController as? UITabBarController {
+            rootViewController = tabBarController.selectedViewController
+          }
+          rootViewController?.present(alert, animated: true, completion: nil)
+        }
+      }
+    } else {
+      if status == .notDetermined {
+        // Fresh install: defer the promise until the OS reports the user's
+        // choice via locationManagerDidChangeAuthorization(_:). Not settling
+        // here would hang the JS caller forever.
+        permissionResolve = resolve
+        self.templocationChecker.requestWhenInUseAuthorization()
+      } else if status == .authorizedWhenInUse {
+        resolve(WoosmapGeofenceMessage.samePermission)
+      } else {
+        resolve(WoosmapGeofenceMessage.showingPermissionBox)
+        Task { @MainActor in
+          let appname: String = Bundle.main.infoDictionary?[kCFBundleNameKey as String] as? String ?? ""
+          var alertInfo: String = ""
+          if status == .denied {
+            alertInfo = String(format: WoosmapGeofenceMessage.deniedPermission, appname)
+          } else {
+            alertInfo = String(format: WoosmapGeofenceMessage.replacePermission, appname)
+          }
+          let alert = UIAlertController(title: "", message: alertInfo, preferredStyle: UIAlertController.Style.alert)
+          alert.addAction(UIAlertAction(title: WoosmapGeofenceMessage.cancel, style: UIAlertAction.Style.default, handler: nil))
+          alert.addAction(UIAlertAction(title: WoosmapGeofenceMessage.setting, style: UIAlertAction.Style.default, handler: { _ in
+            if let settingsUrl = URL(string: UIApplication.openSettingsURLString) {
+              UIApplication.shared.open(settingsUrl, options: [:], completionHandler: nil)
+            }
+          }))
+          var rootViewController = UIApplication.shared.topViewController
+          if let navigationController = rootViewController as? UINavigationController {
+            rootViewController = navigationController.viewControllers.first
+          }
+          if let tabBarController = rootViewController as? UITabBarController {
+            rootViewController = tabBarController.selectedViewController
+          }
+          rootViewController?.present(alert, animated: true, completion: nil)
+        }
+      }
+    }
+  }
+
+  /// Requests Bluetooth permission. iOS does not require an explicit BLE
+  /// permission for geofencing, so this always resolves `GRANTED`.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with `"GRANTED"`.
+  ///   - reject: Promise rejecter (unused on iOS).
+  @objc(requestBLEPermissions:reject:)
+  func requestBLEPermissions(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    resolve("GRANTED")
+  }
+
+  /// Requests notification permission. iOS does not require this for
+  /// geofencing, so this always resolves `GRANTED`.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with `"GRANTED"`.
+  ///   - reject: Promise rejecter (unused on iOS).
+  @objc(requestNotificationPermissions:reject:)
+  func requestNotificationPermissions(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    resolve("GRANTED")
+  }
+
+  // MARK: - Watch / clear location
+
+  /// Registers a location watch. The first watcher subscribes to `.newLocationSaved`.
+  /// - Parameters:
+  ///   - watchid: The caller-provided identifier for this watch.
+  ///   - resolve: Promise resolver invoked with `watchid` on success.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(watchLocation:resolve:reject:)
+  func watchLocation(watchid: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    if WoosmapGeofenceService.shared != nil {
+      locationWatchStack[watchid] = watchid
+      if locationWatchStack.count == 1 {
+        NotificationCenter.default.addObserver(
+          self,
+          selector: #selector(newLocationAdded(_:)),
+          name: .newLocationSaved,
+          object: nil)
+      }
+      resolve(watchid)
+    } else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+    }
+  }
+
+  /// Removes the location watch with the given ID, unsubscribing once empty.
+  /// - Parameters:
+  ///   - watchid: The identifier of the watch to remove.
+  ///   - resolve: Promise resolver invoked with `watchid`.
+  ///   - reject: Promise rejecter (unused).
+  @objc(clearLocationWatch:resolve:reject:)
+  func clearLocationWatch(watchid: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    if let _ = locationWatchStack[watchid] {
+      locationWatchStack.removeValue(forKey: watchid)
+    }
+    if locationWatchStack.count == 0 {
+      NotificationCenter.default.removeObserver(self, name: .newLocationSaved, object: nil)
+    }
+    resolve(watchid)
+  }
+
+  /// Removes all active location watches and unsubscribes from updates.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with a sentinel watch ID.
+  ///   - reject: Promise rejecter (unused).
+  @objc(clearAllLocationWatch:reject:)
+  func clearAllLocationWatch(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    locationWatchStack.removeAll()
+    NotificationCenter.default.removeObserver(self, name: .newLocationSaved, object: nil)
+    resolve("00000-00000-0000")
+  }
+
+  // MARK: - Watch / clear regions
+
+  /// Registers a region watch. The first watcher subscribes to `.didEventPOIRegion`.
+  /// - Parameters:
+  ///   - watchid: The caller-provided identifier for this watch.
+  ///   - resolve: Promise resolver invoked with `watchid` on success.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(watchRegions:resolve:reject:)
+  func watchRegions(watchid: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    if WoosmapGeofenceService.shared != nil {
+      regionWatchStack[watchid] = watchid
+      if regionWatchStack.count == 1 {
+        NotificationCenter.default.addObserver(
+          self,
+          selector: #selector(didEventPOIRegion(_:)),
+          name: .didEventPOIRegion,
+          object: nil)
+      }
+      resolve(watchid)
+    } else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+    }
+  }
+
+  /// Removes the region watch with the given ID, unsubscribing once empty.
+  /// - Parameters:
+  ///   - watchid: The identifier of the watch to remove.
+  ///   - resolve: Promise resolver invoked with `watchid`.
+  ///   - reject: Promise rejecter (unused).
+  @objc(clearRegionsWatch:resolve:reject:)
+  func clearRegionsWatch(watchid: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    if let _ = regionWatchStack[watchid] {
+      regionWatchStack.removeValue(forKey: watchid)
+    }
+    if regionWatchStack.count == 0 {
+      NotificationCenter.default.removeObserver(self, name: .didEventPOIRegion, object: nil)
+    }
+    resolve(watchid)
+  }
+
+  /// Removes all active region watches and unsubscribes from updates.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with a sentinel watch ID.
+  ///   - reject: Promise rejecter (unused).
+  @objc(clearAllRegionsWatch:reject:)
+  func clearAllRegionsWatch(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    regionWatchStack.removeAll()
+    NotificationCenter.default.removeObserver(self, name: .didEventPOIRegion, object: nil)
+    resolve("00000-00000-0000")
+  }
+
+  // MARK: - Region CRUD
+
+  /// Sets the Woosmap private API key on the running service.
+  /// - Parameters:
+  ///   - apiKey: The new Woosmap private API key.
+  ///   - resolve: Promise resolver invoked on success.
+  ///   - reject: Promise rejecter invoked on an empty key or failure.
   @objc(setWoosmapApiKey:resolve:reject:)
   func setWoosmapApiKey(apiKey: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
     guard let woosService = WoosmapGeofenceService.shared else {
@@ -63,6 +488,11 @@ class WoosmapGeofencingTurbo: NSObject {
     }
   }
 
+  /// Sets the POI geofence radius, accepting a number, double or property name.
+  /// - Parameters:
+  ///   - radius: The radius value (e.g. `"100"`) or a user-property name.
+  ///   - resolve: Promise resolver invoked on success.
+  ///   - reject: Promise rejecter invoked on an empty/invalid value.
   @objc(setPoiRadius:resolve:reject:)
   func setPoiRadius(radius: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
     guard let woosService = WoosmapGeofenceService.shared else {
@@ -89,6 +519,11 @@ class WoosmapGeofencingTurbo: NSObject {
     resolve(WoosmapGeofenceMessage.initialize)
   }
 
+  /// Adds a custom region (circle or isochrone) to monitor.
+  /// - Parameters:
+  ///   - region: A dictionary with `regionId`, `lat`, `lng`, `radius`, `type`.
+  ///   - resolve: Promise resolver invoked with the created region identifier.
+  ///   - reject: Promise rejecter invoked on validation failure or a duplicate ID.
   @objc(addRegion:resolve:reject:)
   func addRegion(region: NSDictionary, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
     guard let woosService = WoosmapGeofenceService.shared else {
@@ -165,6 +600,11 @@ class WoosmapGeofencingTurbo: NSObject {
     }
   }
 
+  /// Retrieves saved regions. With an ID, returns the single match; otherwise all.
+  /// - Parameters:
+  ///   - regionId: An optional region identifier to filter by.
+  ///   - resolve: Promise resolver invoked with an array of region dictionaries.
+  ///   - reject: Promise rejecter invoked when the ID is not found.
   @objc(getRegions:resolve:reject:)
   func getRegions(regionId: String?, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
     guard let woosService = WoosmapGeofenceService.shared else {
@@ -173,10 +613,6 @@ class WoosmapGeofencingTurbo: NSObject {
              woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
       return
     }
-
-    // The spec collapses the legacy getAllRegions()/getRegions(id) pair into a
-    // single optional-arg method that always resolves an array. A nil/empty id
-    // returns the whole collection.
     if let regionId = regionId, !regionId.isEmpty {
       if let captured = woosService.getRegions(id: regionId) {
         resolve([formatRegionData(woosdata: captured)])
@@ -191,6 +627,10 @@ class WoosmapGeofencingTurbo: NSObject {
     }
   }
 
+  /// Removes all saved regions.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked once regions are deleted.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
   @objc(removeAllRegions:reject:)
   func removeAllRegions(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
     guard let woosService = WoosmapGeofenceService.shared else {
@@ -203,6 +643,11 @@ class WoosmapGeofencingTurbo: NSObject {
     resolve(WoosmapGeofenceMessage.regionDeleted)
   }
 
+  /// Removes the saved region with the given identifier.
+  /// - Parameters:
+  ///   - regionId: The identifier of the region to remove.
+  ///   - resolve: Promise resolver invoked once the region is deleted.
+  ///   - reject: Promise rejecter invoked on a missing ID or failure.
   @objc(removeRegion:resolve:reject:)
   func removeRegion(regionId: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
     guard let woosService = WoosmapGeofenceService.shared else {
@@ -226,4 +671,421 @@ class WoosmapGeofencingTurbo: NSObject {
              woosmapError(error.localizedDescription))
     }
   }
+
+  // MARK: - Tracking
+
+  /// Starts tracking using the given configuration profile.
+  /// - Parameters:
+  ///   - profile: The tracking profile name (e.g. `liveTracking`).
+  ///   - resolve: Promise resolver invoked on success.
+  ///   - reject: Promise rejecter invoked on an invalid profile or failure.
+  @objc(startTracking:resolve:reject:)
+  func startTracking(profile: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    do {
+      try woosService.startTracking(profile: profile)
+      resolve(WoosmapGeofenceMessage.initialize)
+    } catch {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             error.localizedDescription,
+             woosmapError(error.localizedDescription))
+    }
+  }
+
+  /// Stops location tracking.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked on success.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(stopTracking:reject:)
+  func stopTracking(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    woosService.stopTracking()
+    resolve(WoosmapGeofenceMessage.initialize)
+  }
+
+  /// Starts tracking from a custom profile hosted locally or externally.
+  /// - Parameters:
+  ///   - mode: The profile source (`local` or `external`).
+  ///   - source: The file name or URL of the profile.
+  ///   - resolve: Promise resolver invoked once the profile is applied.
+  ///   - reject: Promise rejecter invoked on failure.
+  @objc(startCustomTracking:source:resolve:reject:)
+  func startCustomTracking(mode: String,
+                           source: String,
+                           resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    woosService.startCustomTracking(mode: mode, source: source) { value, error in
+      if let functionError = error {
+        reject(WoosmapGeofenceMessage.plugin_errorDomain,
+               functionError.localizedDescription,
+               self.woosmapError(functionError.localizedDescription))
+      } else if value {
+        resolve(WoosmapGeofenceMessage.initialize)
+      } else {
+        // value == false with no error: the profile could not be applied.
+        // Reject so the JS promise always settles instead of hanging.
+        reject(WoosmapGeofenceMessage.plugin_errorDomain,
+               WoosmapGeofenceMessage.invalid_profilefile,
+               self.woosmapError(WoosmapGeofenceMessage.invalid_profilefile))
+      }
+    }
+  }
+
+  // MARK: - Permissions status
+
+  /// Reports the current location-permission status.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with `GRANTED_BACKGROUND`,
+  ///     `GRANTED_FOREGROUND`, `DENIED` or `UNKNOWN`.
+  ///   - reject: Promise rejecter (unused).
+  @objc(getPermissionsStatus:reject:)
+  func getPermissionsStatus(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    // CLLocationManager must be created/queried on the main thread; bridge
+    // methods otherwise run on a background queue.
+    DispatchQueue.main.async {
+      let authorizationStatus: CLAuthorizationStatus
+      if #available(iOS 14, *) {
+        authorizationStatus = CLLocationManager().authorizationStatus
+      } else {
+        authorizationStatus = CLLocationManager.authorizationStatus()
+      }
+      let str: String
+      switch authorizationStatus {
+      case .denied, .restricted:
+        str = "DENIED"
+      case .authorizedAlways:
+        str = "GRANTED_BACKGROUND"
+      case .authorizedWhenInUse:
+        str = "GRANTED_FOREGROUND"
+      default:
+        str = "UNKNOWN"
+      }
+      resolve(str)
+    }
+  }
+
+  /// Reports the Bluetooth-permission status. Not required on iOS for
+  /// geofencing, so this always resolves `GRANTED`.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with `"GRANTED"`.
+  ///   - reject: Promise rejecter (unused).
+  @objc(getBLEPermissionsStatus:reject:)
+  func getBLEPermissionsStatus(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    resolve("GRANTED")
+  }
+
+  /// Reports the notification-permission status. Not required on iOS for
+  /// geofencing tracking, so this always resolves `GRANTED`.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with `"GRANTED"`.
+  ///   - reject: Promise rejecter (unused).
+  @objc(getNotificationPermissionsStatus:reject:)
+  func getNotificationPermissionsStatus(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    resolve("GRANTED")
+  }
+
+  // MARK: - Configuration
+
+  /// Sets the Salesforce Marketing Cloud (SFMC) credentials.
+  /// - Parameters:
+  ///   - credentials: A dictionary of SFMC credential key/value pairs.
+  ///   - resolve: Promise resolver invoked on success.
+  ///   - reject: Promise rejecter invoked on invalid credentials or failure.
+  @objc(setSFMCCredentials:resolve:reject:)
+  func setSFMCCredentials(credentials: NSDictionary, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    guard let creds = credentials as? [String: String] else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.invalidSFMCCredentials,
+             woosmapError(WoosmapGeofenceMessage.invalidSFMCCredentials))
+      return
+    }
+    do {
+      try woosService.setSFMCCredentials(credentials: creds)
+      resolve(WoosmapGeofenceMessage.initialize)
+    } catch {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             error.localizedDescription,
+             woosmapError(error.localizedDescription))
+    }
+  }
+
+  /// Reserves protected region slots for third-party SDKs (max 3).
+  /// - Parameters:
+  ///   - slots: The number of slots to reserve.
+  ///   - resolve: Promise resolver invoked on success.
+  ///   - reject: Promise rejecter invoked on an invalid slot count.
+  @objc(setProtectedRegionSlot:resolve:reject:)
+  func setProtectedRegionSlot(slots: NSNumber, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard WoosmapGeofenceService.shared != nil else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    do {
+      try WoosmapGeofenceService.shared?.setProtectedRegionSlot(slots: slots.intValue)
+      resolve(WoosmapGeofenceMessage.initialize)
+    } catch {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.invalidProtectedRegionSlot,
+             woosmapError(WoosmapGeofenceMessage.invalidProtectedRegionSlot))
+    }
+  }
+
+  // MARK: - Data queries
+
+  /// Retrieves saved locations. With an ID, returns the single match; otherwise all.
+  /// - Parameters:
+  ///   - locationId: An optional location identifier to filter by.
+  ///   - resolve: Promise resolver invoked with an array of location dictionaries.
+  ///   - reject: Promise rejecter invoked when the ID is not found.
+  @objc(getLocations:resolve:reject:)
+  func getLocations(locationId: String?, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    if let locationId = locationId, !locationId.isEmpty {
+      if let captured = woosService.getLocations(id: locationId) {
+        resolve([formatLocationData(woosdata: captured)])
+      } else {
+        reject(WoosmapGeofenceMessage.plugin_errorDomain,
+               WoosmapGeofenceMessage.notfound_locationid,
+               woosmapError(WoosmapGeofenceMessage.notfound_locationid))
+      }
+    } else {
+      resolve(woosService.getLocations().map { formatLocationData(woosdata: $0) })
+    }
+  }
+
+  /// Retrieves saved POIs. With an ID, returns the single match; otherwise all.
+  /// - Parameters:
+  ///   - poiId: An optional POI identifier (location or store ID) to filter by.
+  ///   - resolve: Promise resolver invoked with an array of POI dictionaries.
+  ///   - reject: Promise rejecter invoked when the ID is not found.
+  @objc(getPois:resolve:reject:)
+  func getPois(poiId: String?, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    if let poiId = poiId, !poiId.isEmpty {
+      if let captured = woosService.getPOIs(id: poiId) {
+        resolve([formatPOIData(woosdata: captured)])
+      } else {
+        reject(WoosmapGeofenceMessage.plugin_errorDomain,
+               WoosmapGeofenceMessage.notfound_poiid,
+               woosmapError(WoosmapGeofenceMessage.notfound_poiid))
+      }
+    } else {
+      resolve(woosService.getPOIs().map { formatPOIData(woosdata: $0) })
+    }
+  }
+
+  /// Retrieves saved indoor beacons, optionally filtered by venue.
+  /// - Parameters:
+  ///   - venueId: An optional venue identifier to filter by.
+  ///   - resolve: Promise resolver invoked with an array of beacon dictionaries.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(getIndoorBeacons:resolve:reject:)
+  func getIndoorBeacons(venueId: String?, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    let beacons = woosService.getIndoorBeacons(id: venueId) ?? []
+    resolve(beacons.map { formatIndoorBeaconData(woosdata: $0) })
+  }
+
+  // MARK: - Data removal
+
+  /// Removes all saved locations.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked once locations are deleted.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(removeLocations:reject:)
+  func removeLocations(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    woosService.deleteAllLocations()
+    resolve(WoosmapGeofenceMessage.locationDeleted)
+  }
+
+  /// Removes all saved POIs.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked once POIs are deleted.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(removePois:reject:)
+  func removePois(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    woosService.deletePOI()
+    resolve(WoosmapGeofenceMessage.poiDeleted)
+  }
+
+  /// Removes all saved indoor beacons.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked once beacons are deleted.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(removeIndoorBeacons:reject:)
+  func removeIndoorBeacons(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    woosService.deleteIndoorBeacons()
+    resolve(WoosmapGeofenceMessage.locationDeleted)
+  }
+
+  /// Refreshes POI data from the Woosmap server.
+  /// - Parameters:
+  ///   - resolve: Promise resolver invoked with the refresh status.
+  ///   - reject: Promise rejecter invoked when the service is not initialized.
+  @objc(refreshPois:reject:)
+  func refreshPois(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    guard let woosService = WoosmapGeofenceService.shared else {
+      reject(WoosmapGeofenceMessage.plugin_errorDomain,
+             WoosmapGeofenceMessage.woosmapNotInitialized,
+             woosmapError(WoosmapGeofenceMessage.woosmapNotInitialized))
+      return
+    }
+    woosService.refreshPOI()
+    resolve(WoosmapGeofenceMessage.refreshPOIStatus)
+  }
+
+  // MARK: - Notification handlers
+
+  /// Handles `.newLocationSaved` notifications and forwards them to JS as a
+  /// `geolocationDidChange` event when at least one watcher is active.
+  /// - Parameter notification: The notification carrying the new `Location`.
+  @objc func newLocationAdded(_ notification: Notification) {
+    if let location = notification.userInfo?["Location"] as? Location {
+      if locationWatchStack.count > 0 {
+        sendEvent(withName: "geolocationDidChange", body: formatLocationData(woosdata: location))
+      }
+    }
+  }
+
+  /// Handles `.didEventPOIRegion` notifications and forwards them to JS as a
+  /// `woosmapgeofenceRegionDidChange` event.
+  /// - Parameter notification: The notification carrying the `Region`.
+  @objc func didEventPOIRegion(_ notification: Notification) {
+    if let region = notification.userInfo?["Region"] as? Region {
+      sendEvent(withName: "woosmapgeofenceRegionDidChange", body: formatRegionData(woosdata: region))
+    }
+  }
+}
+
+// MARK: - CLLocationManagerDelegate
+
+extension WoosmapGeofencingTurbo: CLLocationManagerDelegate {
+  /// Receives location updates from the permission-checking manager.
+  /// - Parameters:
+  ///   - manager: The location manager reporting the update.
+  ///   - locations: The array of new locations; only the last is used.
+  func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+    guard let location = locations.last else { return }
+    print(location)
+  }
+
+  /// Settles an in-flight `requestPermissions` promise once the user answers the
+  /// system location dialog. Mirrors the Android `onRequestPermissionsResult`
+  /// path so a fresh install no longer hangs. No-ops when there is no pending
+  /// request (e.g. the initial callback fired on delegate assignment) or while
+  /// the dialog is still showing (`.notDetermined`).
+  /// - Parameter manager: The location manager reporting the change.
+  func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+    guard let resolve = permissionResolve else { return }
+    let status = manager.authorizationStatus
+    if status == .notDetermined { return }
+    permissionResolve = nil
+    switch status {
+    case .authorizedAlways:
+      resolve("GRANTED_BACKGROUND")
+    case .authorizedWhenInUse:
+      resolve("GRANTED_FOREGROUND")
+    case .denied, .restricted:
+      resolve("DENIED")
+    default:
+      resolve("UNKNOWN")
+    }
+  }
+
+  /// Receives location-manager failures.
+  /// - Parameters:
+  ///   - manager: The location manager reporting the failure.
+  ///   - error: The error that occurred.
+  private func locationManager(manager: CLLocationManager, didFailWithError error: NSError) {
+    print(error)
+  }
+}
+
+// MARK: - UIApplication top view controller
+
+extension UIApplication {
+  /// The top-most view controller in the app, used to present permission alerts.
+  /// - Returns: The visible view controller, or `nil` if no key window is found.
+  var topViewController: UIViewController? {
+    guard let windowScene = connectedScenes
+            .first(where: { $0.activationState == .foregroundActive }) as? UIWindowScene,
+          let rootVC = windowScene.windows
+            .first(where: { $0.isKeyWindow })?.rootViewController
+    else {
+      return nil
+    }
+    return topViewController(from: rootVC)
+  }
+
+  /// Recursively walks presented / navigation / tab controllers to find the top one.
+  /// - Parameter root: The view controller to start the walk from.
+  /// - Returns: The top-most view controller reachable from `root`.
+  private func topViewController(from root: UIViewController) -> UIViewController {
+    if let presented = root.presentedViewController {
+      return topViewController(from: presented)
+    } else if let nav = root as? UINavigationController, let visible = nav.visibleViewController {
+      return topViewController(from: visible)
+    } else if let tab = root as? UITabBarController, let selected = tab.selectedViewController {
+      return topViewController(from: selected)
+    } else {
+      return root
+    }
+  }
 }