react-native-nitro-location-tracking 0.1.5 → 0.1.6

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/GeofenceManager.kt

@@ -0,0 +1,148 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.google.android.gms.location.Geofence
+import com.google.android.gms.location.GeofencingClient
+import com.google.android.gms.location.GeofencingRequest
+import com.google.android.gms.location.LocationServices
+
+class GeofenceManager(private val context: Context) {
+
+    companion object {
+        private const val TAG = "GeofenceManager"
+        private const val ACTION_GEOFENCE = "com.margelo.nitro.nitrolocationtracking.GEOFENCE_EVENT"
+    }
+
+    private val geofencingClient: GeofencingClient =
+        LocationServices.getGeofencingClient(context)
+    private val activeRegions = mutableMapOf<String, GeofenceRegion>()
+    private var callback: ((GeofenceEvent, String) -> Unit)? = null
+    private var receiver: BroadcastReceiver? = null
+
+    fun setCallback(callback: (GeofenceEvent, String) -> Unit) {
+        this.callback = callback
+        registerReceiver()
+    }
+
+    @SuppressLint("MissingPermission")
+    fun addGeofence(region: GeofenceRegion) {
+        val geofence = Geofence.Builder()
+            .setRequestId(region.id)
+            .setCircularRegion(region.latitude, region.longitude, region.radius.toFloat())
+            .setExpirationDuration(Geofence.NEVER_EXPIRE)
+            .setTransitionTypes(buildTransitionTypes(region))
+            .build()
+
+        val request = GeofencingRequest.Builder()
+            .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER)
+            .addGeofence(geofence)
+            .build()
+
+        geofencingClient.addGeofences(request, getGeofencePendingIntent())
+            .addOnSuccessListener {
+                activeRegions[region.id] = region
+                Log.d(TAG, "Geofence added: ${region.id}")
+            }
+            .addOnFailureListener { e ->
+                Log.e(TAG, "Failed to add geofence ${region.id}: ${e.message}")
+            }
+    }
+
+    fun removeGeofence(regionId: String) {
+        geofencingClient.removeGeofences(listOf(regionId))
+            .addOnSuccessListener {
+                activeRegions.remove(regionId)
+                Log.d(TAG, "Geofence removed: $regionId")
+            }
+            .addOnFailureListener { e ->
+                Log.e(TAG, "Failed to remove geofence $regionId: ${e.message}")
+            }
+    }
+
+    fun removeAllGeofences() {
+        geofencingClient.removeGeofences(getGeofencePendingIntent())
+            .addOnSuccessListener {
+                activeRegions.clear()
+                Log.d(TAG, "All geofences removed")
+            }
+            .addOnFailureListener { e ->
+                Log.e(TAG, "Failed to remove all geofences: ${e.message}")
+            }
+    }
+
+    private fun buildTransitionTypes(region: GeofenceRegion): Int {
+        var types = 0
+        if (region.notifyOnEntry) types = types or Geofence.GEOFENCE_TRANSITION_ENTER
+        if (region.notifyOnExit) types = types or Geofence.GEOFENCE_TRANSITION_EXIT
+        return types
+    }
+
+    private fun getGeofencePendingIntent(): PendingIntent {
+        val intent = Intent(ACTION_GEOFENCE).apply {
+            setPackage(context.packageName)
+        }
+        val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
+        return PendingIntent.getBroadcast(context, 0, intent, flags)
+    }
+
+    private fun registerReceiver() {
+        if (receiver != null) return
+
+        receiver = object : BroadcastReceiver() {
+            override fun onReceive(ctx: Context?, intent: Intent?) {
+                if (intent?.action != ACTION_GEOFENCE) return
+                val geofencingEvent = com.google.android.gms.location.GeofencingEvent.fromIntent(intent)
+                if (geofencingEvent == null || geofencingEvent.hasError()) {
+                    Log.e(TAG, "Geofencing event error: ${geofencingEvent?.errorCode}")
+                    return
+                }
+
+                val transition = geofencingEvent.geofenceTransition
+                val event = when (transition) {
+                    Geofence.GEOFENCE_TRANSITION_ENTER -> GeofenceEvent.ENTER
+                    Geofence.GEOFENCE_TRANSITION_EXIT -> GeofenceEvent.EXIT
+                    else -> return
+                }
+
+                geofencingEvent.triggeringGeofences?.forEach { geofence ->
+                    callback?.invoke(event, geofence.requestId)
+                }
+            }
+        }
+
+        val filter = IntentFilter(ACTION_GEOFENCE)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+          ContextCompat.registerReceiver(
+            context,
+            receiver,
+            filter,
+            ContextCompat.RECEIVER_NOT_EXPORTED
+          )
+        }
+    }
+
+    fun destroy() {
+        removeAllGeofences()
+        receiver?.let {
+            try {
+                context.unregisterReceiver(it)
+            } catch (_: Exception) {}
+        }
+        receiver = null
+        callback = null
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/LocationEngine.kt

@@ -1,9 +1,12 @@
 package com.margelo.nitro.nitrolocationtracking
 
 import android.annotation.SuppressLint
+import android.app.AppOpsManager
 import android.content.Context
 import android.location.Location
+import android.os.Build
 import android.os.Looper
+import android.provider.Settings
 import android.util.Log
 import com.google.android.gms.location.*
 import kotlin.coroutines.resume
@@ -21,6 +24,9 @@ class LocationEngine(private val context: Context) {
   var onMotionChange: ((Boolean) -> Unit)? = null
   var dbWriter: NativeDBWriter? = null
   var currentRideId: String? = null
+  var rejectMockLocations: Boolean = false
+  val speedMonitor = SpeedMonitor()
+  val tripCalculator = TripCalculator()
   private var lastSpeed = 0f
   private var tracking = false
 
@@ -86,14 +92,31 @@ class LocationEngine(private val context: Context) {
 
   private fun processLocation(location: Location) {
     val data = locationToData(location)
+
+    // Skip mock locations if rejection is enabled
+    if (rejectMockLocations && data.isMockLocation == true) {
+      Log.d(TAG, "Rejecting mock location")
+      return
+    }
+
     onLocation?.invoke(data)
 
+    // Feed to speed monitor and trip calculator
+    speedMonitor.feedLocation(data)
+    tripCalculator.feedLocation(data)
+
     val isMoving = location.speed > 0.5f
     if (isMoving != (lastSpeed > 0.5f)) onMotionChange?.invoke(isMoving)
     lastSpeed = location.speed
   }
 
   private fun locationToData(location: Location): LocationData {
+    val isMock = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      location.isMock
+    } else {
+      @Suppress("DEPRECATION")
+      location.isFromMockProvider
+    }
     return LocationData(
       latitude = location.latitude,
       longitude = location.longitude,
@@ -101,7 +124,38 @@ class LocationEngine(private val context: Context) {
       speed = location.speed.toDouble(),
       bearing = location.bearing.toDouble(),
       accuracy = location.accuracy.toDouble(),
-      timestamp = location.time.toDouble()
+      timestamp = location.time.toDouble(),
+      isMockLocation = isMock
     )
   }
+
+  @SuppressLint("DiscouragedPrivateApi")
+  fun isFakeGpsEnabled(): Boolean {
+    // Pre-API 23: check the global mock location setting
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      @Suppress("DEPRECATION")
+      val mockSetting = Settings.Secure.getString(
+        context.contentResolver,
+        Settings.Secure.ALLOW_MOCK_LOCATION
+      )
+      return mockSetting == "1"
+    }
+
+    // API 23+: check if any app holds MOCK_LOCATION permission via AppOpsManager
+    try {
+      val appOps = context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+      // Use reflection to access undocumented OP_MOCK_LOCATION (op code 58)
+      val opMockLocation = 58
+      val method = AppOpsManager::class.java.getMethod(
+        "checkOp", Int::class.javaPrimitiveType, Int::class.javaPrimitiveType, String::class.java
+      )
+      val result = method.invoke(
+        appOps, opMockLocation, android.os.Process.myUid(), context.packageName
+      ) as Int
+      return result == AppOpsManager.MODE_ALLOWED
+    } catch (e: Exception) {
+      Log.w(TAG, "Could not check mock location app ops: ${e.message}")
+    }
+    return false
+  }
 }

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/NitroLocationTracking.kt

@@ -19,11 +19,16 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
     private var connectionManager = ConnectionManager()
     private var dbWriter: NativeDBWriter? = null
     private var notificationService: NotificationService? = null
+    private var geofenceManager: GeofenceManager? = null
+    private var providerStatusMonitor: ProviderStatusMonitor? = null
 
     private var locationCallback: ((LocationData) -> Unit)? = null
     private var motionCallback: ((Boolean) -> Unit)? = null
     private var connectionStateCallback: ((ConnectionState) -> Unit)? = null
     private var messageCallback: ((String) -> Unit)? = null
+    private var geofenceCallback: ((GeofenceEvent, String) -> Unit)? = null
+    private var speedAlertCallback: ((SpeedAlertType, Double) -> Unit)? = null
+    private var providerStatusCallback: ((LocationProviderStatus, LocationProviderStatus) -> Unit)? = null
 
     private var locationConfig: LocationConfig? = null
 
@@ -37,6 +42,8 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
         locationEngine = LocationEngine(context)
         dbWriter = NativeDBWriter(context)
         notificationService = NotificationService(context)
+        geofenceManager = GeofenceManager(context)
+        providerStatusMonitor = ProviderStatusMonitor(context)
         locationEngine?.dbWriter = dbWriter
         connectionManager.dbWriter = dbWriter
         Log.d(TAG, "Components initialized successfully")
@@ -158,6 +165,124 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
         }
     }
 
+    // === Fake GPS Detection ===
+
+    override fun isFakeGpsEnabled(): Boolean {
+        ensureInitialized()
+        return locationEngine?.isFakeGpsEnabled() ?: false
+    }
+
+    override fun setRejectMockLocations(reject: Boolean) {
+        ensureInitialized()
+        locationEngine?.rejectMockLocations = reject
+    }
+
+    // === Geofencing ===
+
+    override fun addGeofence(region: GeofenceRegion) {
+        ensureInitialized()
+        geofenceManager?.addGeofence(region)
+    }
+
+    override fun removeGeofence(regionId: String) {
+        ensureInitialized()
+        geofenceManager?.removeGeofence(regionId)
+    }
+
+    override fun removeAllGeofences() {
+        ensureInitialized()
+        geofenceManager?.removeAllGeofences()
+    }
+
+    override fun onGeofenceEvent(callback: (event: GeofenceEvent, regionId: String) -> Unit) {
+        geofenceCallback = callback
+        ensureInitialized()
+        geofenceManager?.setCallback(callback)
+    }
+
+    // === Speed Monitoring ===
+
+    override fun configureSpeedMonitor(config: SpeedConfig) {
+        ensureInitialized()
+        locationEngine?.speedMonitor?.configure(config)
+    }
+
+    override fun onSpeedAlert(callback: (alert: SpeedAlertType, currentSpeedKmh: Double) -> Unit) {
+        speedAlertCallback = callback
+        ensureInitialized()
+        locationEngine?.speedMonitor?.setCallback(callback)
+    }
+
+    override fun getCurrentSpeed(): Double {
+        return locationEngine?.speedMonitor?.getCurrentSpeed() ?: 0.0
+    }
+
+    // === Distance Calculator ===
+
+    override fun startTripCalculation() {
+        ensureInitialized()
+        locationEngine?.tripCalculator?.start()
+    }
+
+    override fun stopTripCalculation(): TripStats {
+        return locationEngine?.tripCalculator?.stop() ?: TripStats(
+            distanceMeters = 0.0, durationMs = 0.0, averageSpeedKmh = 0.0,
+            maxSpeedKmh = 0.0, pointCount = 0.0
+        )
+    }
+
+    override fun getTripStats(): TripStats {
+        return locationEngine?.tripCalculator?.getStats() ?: TripStats(
+            distanceMeters = 0.0, durationMs = 0.0, averageSpeedKmh = 0.0,
+            maxSpeedKmh = 0.0, pointCount = 0.0
+        )
+    }
+
+    override fun resetTripCalculation() {
+        locationEngine?.tripCalculator?.reset()
+    }
+
+    // === Location Provider Status ===
+
+    override fun isLocationServicesEnabled(): Boolean {
+        ensureInitialized()
+        return providerStatusMonitor?.isLocationServicesEnabled() ?: false
+    }
+
+    override fun onProviderStatusChange(callback: (gps: LocationProviderStatus, network: LocationProviderStatus) -> Unit) {
+        providerStatusCallback = callback
+        ensureInitialized()
+        providerStatusMonitor?.setCallback(callback)
+    }
+
+    // === Permission Status ===
+
+    override fun getLocationPermissionStatus(): PermissionStatus {
+        val context = NitroModules.applicationContext ?: return PermissionStatus.NOTDETERMINED
+
+        val fineGranted = androidx.core.content.ContextCompat.checkSelfPermission(
+            context, android.Manifest.permission.ACCESS_FINE_LOCATION
+        ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+
+        if (!fineGranted) {
+            // Check if we've ever asked — if the app just installed, it's "notDetermined"
+            // Android doesn't have a direct "notDetermined" state, so we treat
+            // not-granted as DENIED (the JS side can use requestPermission to prompt)
+            return PermissionStatus.DENIED
+        }
+
+        // Fine location granted — check background
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
+            val bgGranted = androidx.core.content.ContextCompat.checkSelfPermission(
+                context, android.Manifest.permission.ACCESS_BACKGROUND_LOCATION
+            ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+            return if (bgGranted) PermissionStatus.ALWAYS else PermissionStatus.WHENINUSE
+        }
+
+        // Pre-Android 10: fine location = always (no separate background permission)
+        return PermissionStatus.ALWAYS
+    }
+
     // === Notifications ===
 
     override fun showLocalNotification(title: String, body: String) {
@@ -176,5 +301,7 @@ class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
         locationEngine?.stop()
         connectionManager.disconnect()
         notificationService?.stopForegroundService()
+        geofenceManager?.destroy()
+        providerStatusMonitor?.destroy()
     }
 }

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/ProviderStatusMonitor.kt

@@ -0,0 +1,73 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.location.LocationManager
+import android.os.Build
+import android.util.Log
+
+class ProviderStatusMonitor(private val context: Context) {
+
+    companion object {
+        private const val TAG = "ProviderStatusMonitor"
+    }
+
+    private val locationManager =
+        context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+    private var callback: ((LocationProviderStatus, LocationProviderStatus) -> Unit)? = null
+    private var receiver: BroadcastReceiver? = null
+
+    fun setCallback(callback: (LocationProviderStatus, LocationProviderStatus) -> Unit) {
+        this.callback = callback
+        registerReceiver()
+    }
+
+    fun isLocationServicesEnabled(): Boolean {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            locationManager.isLocationEnabled
+        } else {
+            locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) ||
+                    locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
+        }
+    }
+
+    private fun registerReceiver() {
+        if (receiver != null) return
+
+        receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                if (intent?.action == LocationManager.PROVIDERS_CHANGED_ACTION) {
+                    notifyStatus()
+                }
+            }
+        }
+
+        val filter = IntentFilter(LocationManager.PROVIDERS_CHANGED_ACTION)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            context.registerReceiver(receiver, filter)
+        }
+        Log.d(TAG, "Registered provider status receiver")
+    }
+
+    private fun notifyStatus() {
+        val gps = if (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER))
+            LocationProviderStatus.ENABLED else LocationProviderStatus.DISABLED
+        val network = if (locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER))
+            LocationProviderStatus.ENABLED else LocationProviderStatus.DISABLED
+        callback?.invoke(gps, network)
+    }
+
+    fun destroy() {
+        receiver?.let {
+            try {
+                context.unregisterReceiver(it)
+            } catch (_: Exception) {}
+        }
+        receiver = null
+        callback = null
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/SpeedMonitor.kt

@@ -0,0 +1,38 @@
+package com.margelo.nitro.nitrolocationtracking
+
+class SpeedMonitor {
+
+    private var config: SpeedConfig? = null
+    private var callback: ((SpeedAlertType, Double) -> Unit)? = null
+    private var currentState: SpeedAlertType = SpeedAlertType.NORMALIZED
+    private var lastSpeedKmh: Double = 0.0
+
+    fun configure(config: SpeedConfig) {
+        this.config = config
+    }
+
+    fun setCallback(callback: (SpeedAlertType, Double) -> Unit) {
+        this.callback = callback
+    }
+
+    fun getCurrentSpeed(): Double = lastSpeedKmh
+
+    fun feedLocation(data: LocationData) {
+        val cfg = config ?: return
+
+        val speedKmh = data.speed * 3.6 // m/s → km/h
+        lastSpeedKmh = speedKmh
+
+        val newState = when {
+            speedKmh > cfg.maxSpeedKmh -> SpeedAlertType.EXCEEDED
+            speedKmh < cfg.minSpeedKmh -> SpeedAlertType.BELOW_MINIMUM
+            else -> SpeedAlertType.NORMALIZED
+        }
+
+        // Only fire callback on state transitions
+        if (newState != currentState) {
+            currentState = newState
+            callback?.invoke(newState, speedKmh)
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/TripCalculator.kt

@@ -0,0 +1,85 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import kotlin.math.*
+
+class TripCalculator {
+
+    private var active = false
+    private var startTimeMs: Long = 0L
+    private var totalDistanceMeters: Double = 0.0
+    private var maxSpeedKmh: Double = 0.0
+    private var speedSumKmh: Double = 0.0
+    private var pointCount: Int = 0
+    private var lastLat: Double? = null
+    private var lastLon: Double? = null
+
+    val isActive: Boolean get() = active
+
+    fun start() {
+        reset()
+        active = true
+        startTimeMs = System.currentTimeMillis()
+    }
+
+    fun stop(): TripStats {
+        active = false
+        return getStats()
+    }
+
+    fun getStats(): TripStats {
+        val durationMs = if (startTimeMs > 0) {
+            (System.currentTimeMillis() - startTimeMs).toDouble()
+        } else 0.0
+        val avgSpeed = if (pointCount > 0) speedSumKmh / pointCount else 0.0
+        return TripStats(
+            distanceMeters = totalDistanceMeters,
+            durationMs = durationMs,
+            averageSpeedKmh = avgSpeed,
+            maxSpeedKmh = maxSpeedKmh,
+            pointCount = pointCount.toDouble()
+        )
+    }
+
+    fun reset() {
+        active = false
+        startTimeMs = 0L
+        totalDistanceMeters = 0.0
+        maxSpeedKmh = 0.0
+        speedSumKmh = 0.0
+        pointCount = 0
+        lastLat = null
+        lastLon = null
+    }
+
+    fun feedLocation(data: LocationData) {
+        if (!active) return
+
+        val speedKmh = data.speed * 3.6 // m/s → km/h
+        if (speedKmh > maxSpeedKmh) maxSpeedKmh = speedKmh
+        speedSumKmh += speedKmh
+        pointCount++
+
+        val prevLat = lastLat
+        val prevLon = lastLon
+        lastLat = data.latitude
+        lastLon = data.longitude
+
+        if (prevLat != null && prevLon != null) {
+            totalDistanceMeters += haversine(prevLat, prevLon, data.latitude, data.longitude)
+        }
+    }
+
+    companion object {
+        private const val EARTH_RADIUS_M = 6371000.0
+
+        fun haversine(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
+            val dLat = Math.toRadians(lat2 - lat1)
+            val dLon = Math.toRadians(lon2 - lon1)
+            val a = sin(dLat / 2).pow(2) +
+                    cos(Math.toRadians(lat1)) * cos(Math.toRadians(lat2)) *
+                    sin(dLon / 2).pow(2)
+            val c = 2 * atan2(sqrt(a), sqrt(1 - a))
+            return EARTH_RADIUS_M * c
+        }
+    }
+}

package/ios/GeofenceManager.swift

@@ -0,0 +1,69 @@
+import CoreLocation
+
+class GeofenceManager: NSObject, CLLocationManagerDelegate {
+
+    private let locationManager = CLLocationManager()
+    private var activeRegions = [String: GeofenceRegion]()
+    private var callback: ((GeofenceEvent, String) -> Void)?
+
+    override init() {
+        super.init()
+        locationManager.delegate = self
+    }
+
+    func setCallback(_ callback: @escaping (GeofenceEvent, String) -> Void) {
+        self.callback = callback
+    }
+
+    func addGeofence(_ region: GeofenceRegion) {
+        let clRegion = CLCircularRegion(
+            center: CLLocationCoordinate2D(latitude: region.latitude, longitude: region.longitude),
+            radius: region.radius,
+            identifier: region.id
+        )
+        clRegion.notifyOnEntry = region.notifyOnEntry
+        clRegion.notifyOnExit = region.notifyOnExit
+
+        locationManager.startMonitoring(for: clRegion)
+        activeRegions[region.id] = region
+    }
+
+    func removeGeofence(_ regionId: String) {
+        for monitored in locationManager.monitoredRegions {
+            if monitored.identifier == regionId {
+                locationManager.stopMonitoring(for: monitored)
+                break
+            }
+        }
+        activeRegions.removeValue(forKey: regionId)
+    }
+
+    func removeAllGeofences() {
+        for monitored in locationManager.monitoredRegions {
+            locationManager.stopMonitoring(for: monitored)
+        }
+        activeRegions.removeAll()
+    }
+
+    // MARK: - CLLocationManagerDelegate
+
+    func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+        callback?(.enter, region.identifier)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+        callback?(.exit, region.identifier)
+    }
+
+    func locationManager(_ manager: CLLocationManager, monitoringDidFailFor region: CLRegion?,
+                         withError error: Error) {
+        if let id = region?.identifier {
+            print("[GeofenceManager] Monitoring failed for region \(id): \(error.localizedDescription)")
+        }
+    }
+
+    func destroy() {
+        removeAllGeofences()
+        callback = nil
+    }
+}