react-native-geofence-manager 0.1.0-beta.11 → 0.1.0-beta.13

package/android/src/main/java/com/geofencemanager/GeofenceManagerModule.kt

@@ -1,193 +1,226 @@
 package com.geofencemanager
 
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.SharedPreferences
 import android.util.Log
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableArray
+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
+import org.json.JSONArray
+import org.json.JSONObject
 
 class GeofenceManagerModule(reactContext: ReactApplicationContext) :
-    NativeGeofenceManagerSpec(reactContext), LifecycleEventListener {
+    NativeGeofenceManagerSpec(reactContext) {
 
     companion object {
+        private const val TAG = "GeofenceManager"
         const val NAME = "GeofenceManager"
-        private const val TAG = "GeofenceManagerModule"
-        private const val MAX_REGIONS = 100
-    }
+        const val GEOFENCE_ACTION = "com.geofencemanager.GEOFENCE_TRANSITION"
+        const val GEOFENCE_HEADLESS_TASK_NAME = "GeofenceManagerTransition"
+        private const val GEOFENCE_REQUEST_CODE = 12345
+        private const val PREFS_NAME = "GeofenceManagerPrefs"
+        private const val PREFS_KEY_DETAILS = "geofence_details"
+        private const val PREFS_KEY_LAST_ADD_AT = "geofence_last_add_at"
+        private const val GRACE_PERIOD_MS = 90_000L
+
+        fun isWithinGracePeriod(context: Context): Boolean {
+            val lastAdd = getPrefs(context).getLong(PREFS_KEY_LAST_ADD_AT, 0L)
+            if (lastAdd == 0L) return false
+            return System.currentTimeMillis() - lastAdd < GRACE_PERIOD_MS
+        }
 
-    init {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "🚀 GeofenceManagerModule INICIALIZADO")
-        Log.d(TAG, "📱 ReactContext: $reactContext")
-        Log.d(TAG, "════════════════════════════════════════")
-        GeofenceReceiver.reactContext = reactContext
-        reactContext.addLifecycleEventListener(this)
-    }
+        @Volatile
+        var reactContextRef: ReactApplicationContext? = null
+
+        private val geofenceNames = mutableMapOf<String, String>()
+        private val geofenceDetailsMap = mutableMapOf<String, GeofenceDetails>()
+
+        data class GeofenceDetails(
+            val id: String,
+            val name: String?,
+            val latitude: Double,
+            val longitude: Double,
+            val radius: Float
+        )
+
+        private fun getPrefs(context: Context): SharedPreferences =
+            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+
+        private fun loadDetailsFromPrefs(context: Context) {
+            synchronized(geofenceDetailsMap) {
+                if (geofenceDetailsMap.isNotEmpty()) return@synchronized
+                val json = getPrefs(context).getString(PREFS_KEY_DETAILS, null) ?: return@synchronized
+                try {
+                    val arr = JSONArray(json)
+                    for (i in 0 until arr.length()) {
+                        val o = arr.getJSONObject(i)
+                        val d = GeofenceDetails(
+                            id = o.getString("id"),
+                            name = if (o.has("name")) o.optString("name").takeIf { it.isNotEmpty() } else null,
+                            latitude = o.getDouble("latitude"),
+                            longitude = o.getDouble("longitude"),
+                            radius = o.getDouble("radius").toFloat()
+                        )
+                        geofenceDetailsMap[d.id] = d
+                        d.name?.let { geofenceNames[d.id] = it }
+                    }
+                } catch (e: Exception) {
+                    Log.w(TAG, "loadDetailsFromPrefs failed", e)
+                }
+            }
+        }
 
-    override fun getName(): String = NAME
+        fun getGeofenceName(id: String): String? = geofenceNames[id]
 
-    override fun onHostResume() {
-        Log.d(TAG, "🔄 onHostResume() - App voltou ao foreground")
-        Log.d(TAG, "   └─ Atualizando reactContext no GeofenceReceiver")
-        GeofenceReceiver.reactContext = reactApplicationContext
+        fun getGeofenceDetails(context: Context, id: String): GeofenceDetails? {
+            geofenceDetailsMap[id]?.let { return it }
+            loadDetailsFromPrefs(context)
+            return geofenceDetailsMap[id]
+        }
     }
 
-    override fun onHostPause() {
-        Log.d(TAG, "⏸️ onHostPause() - App foi para background")
+    init {
+        Log.i(TAG, "Module init: package=${reactContext.packageName} hasActivity=${reactContext.currentActivity != null}")
+        // Só guardar o contexto que tem Activity (tela principal). O contexto da headless task
+        // não tem currentActivity; se o armazenarmos, os eventos em foreground (dwell/exit)
+        // seriam emitidos para ele e o listener registrado na tela nunca receberia.
+        if (reactContext.currentActivity != null) {
+            GeofenceManagerModule.reactContextRef = reactContext
+            Log.i(TAG, "Module init: reactContextRef set (foreground JS will receive DeviceEventEmitter events)")
+        } else {
+            Log.w(TAG, "Module init: no currentActivity — reactContextRef NOT updated (normal for some init paths)")
+        }
     }
 
-    override fun onHostDestroy() {
-        Log.d(TAG, "💀 onHostDestroy() - App está sendo destruído")
+    private val applicationContext: Context = reactContext.applicationContext
+    private val geofencingClient: GeofencingClient =
+        LocationServices.getGeofencingClient(applicationContext)
+    private var geofencePendingIntent: PendingIntent? = null
+
+    private fun getPendingIntent(): PendingIntent {
+        geofencePendingIntent?.let {
+            Log.d(TAG, "getPendingIntent: reusing existing PendingIntent")
+            return it
+        }
+        Log.i(TAG, "getPendingIntent: creating new PendingIntent -> GeofenceBroadcastReceiver action=$GEOFENCE_ACTION")
+        val intent = Intent(applicationContext, GeofenceBroadcastReceiver::class.java).apply {
+            action = GEOFENCE_ACTION
+            setPackage(applicationContext.packageName)
+            component = ComponentName(applicationContext, GeofenceBroadcastReceiver::class.java)
+        }
+        geofencePendingIntent = PendingIntent.getBroadcast(
+            applicationContext,
+            GEOFENCE_REQUEST_CODE,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+        )
+        return geofencePendingIntent!!
     }
 
-    override fun start(regions: ReadableArray, options: ReadableMap?, promise: Promise) {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "▶️ START() CHAMADO")
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "📊 Parâmetros recebidos:")
-        Log.d(TAG, "   └─ Quantidade de regiões: ${regions.size()}")
-        Log.d(TAG, "   └─ Options: $options")
+    override fun getName(): String = NAME
 
+    override fun addGeofences(geofences: ReadableArray, promise: Promise) {
+        Log.i(TAG, "addGeofences: start, arraySize=${geofences.size()}")
         try {
-            if (regions.size() > MAX_REGIONS) {
-                Log.e(TAG, "❌ ERRO: Limite de regiões excedido!")
-                Log.e(TAG, "   └─ Máximo permitido: $MAX_REGIONS")
-                Log.e(TAG, "   └─ Recebido: ${regions.size()}")
-                promise.reject(
-                    "GEOFENCE_LIMIT_EXCEEDED",
-                    "Limite máximo de $MAX_REGIONS regiões excedido. Recebido: ${regions.size()}"
+            val list = mutableListOf<Geofence>()
+            for (i in 0 until geofences.size()) {
+                val item: ReadableMap = geofences.getMap(i) ?: run {
+                    Log.w(TAG, "addGeofences: index $i skipped (null map)")
+                    continue
+                }
+                val id = item.getString("id") ?: run {
+                    Log.w(TAG, "addGeofences: index $i skipped (missing id)")
+                    continue
+                }
+                val name = if (item.hasKey("name")) item.getString("name") else null
+                val lat = item.getDouble("latitude")
+                val lng = item.getDouble("longitude")
+                val radius = if (item.hasKey("radius")) item.getDouble("radius").toFloat() else 100f
+                synchronized(GeofenceManagerModule.geofenceNames) {
+                    if (name != null) GeofenceManagerModule.geofenceNames[id] = name
+                    GeofenceManagerModule.geofenceDetailsMap[id] = GeofenceDetails(id, name, lat, lng, radius)
+                }
+                list.add(
+                    Geofence.Builder()
+                        .setRequestId(id)
+                        .setCircularRegion(lat, lng, radius)
+                        .setExpirationDuration(Geofence.NEVER_EXPIRE)
+                        .setLoiteringDelay(30_000)
+                        .setTransitionTypes(
+                            Geofence.GEOFENCE_TRANSITION_ENTER or Geofence.GEOFENCE_TRANSITION_EXIT or Geofence.GEOFENCE_TRANSITION_DWELL
+                        )
+                        .build()
                 )
-                return
+                Log.i(TAG, "addGeofences: parsed geofence id=$id lat=$lat lng=$lng radius=$radius")
             }
-
-            val regionList = parseRegions(regions)
-            val dwellDelay = options?.takeIf { it.hasKey("dwellDelay") }?.getInt("dwellDelay") ?: 5000
-            val headlessTaskTimeout = options?.takeIf { it.hasKey("headlessTaskTimeout") }?.getInt("headlessTaskTimeout") ?: 30000
-
-            Log.d(TAG, "⚙️ Configurações:")
-            Log.d(TAG, "   └─ dwellDelay: ${dwellDelay}ms")
-            Log.d(TAG, "   └─ headlessTaskTimeout: ${headlessTaskTimeout}ms")
-            Log.d(TAG, "📍 Regiões parseadas: ${regionList.size}")
-            regionList.forEachIndexed { index, region ->
-                Log.d(TAG, "   └─ [$index] id=${region.id}, name=${region.name}")
-                Log.d(TAG, "      └─ lat=${region.latitude}, lng=${region.longitude}, radius=${region.radius}m")
+            if (list.isEmpty()) {
+                Log.e(TAG, "addGeofences: no valid geofences — resolving false (check id/latitude/longitude)")
+                promise.resolve(false)
+                return
             }
-
-            Log.d(TAG, "🔄 Chamando RegionManager.registerGeofences()...")
-
-            RegionManager.registerGeofences(
-                context = reactApplicationContext,
-                regions = regionList,
-                dwellDelay = dwellDelay,
-                headlessTaskTimeout = headlessTaskTimeout,
-                onSuccess = {
-                    Log.d(TAG, "✅ START() SUCESSO - Promise resolvida")
-                    promise.resolve(null)
-                },
-                onError = { errorMessage ->
-                    Log.e(TAG, "❌ START() FALHOU - Promise rejeitada")
-                    Log.e(TAG, "   └─ Erro: $errorMessage")
-                    promise.reject("GEOFENCE_ERROR", errorMessage)
+            saveDetailsToPrefs(applicationContext)
+            val request = GeofencingRequest.Builder()
+                .setInitialTrigger(0)
+                .addGeofences(list)
+                .build()
+            Log.i(TAG, "addGeofences: calling GeofencingClient.addGeofences count=${list.size}")
+            geofencingClient.addGeofences(request, getPendingIntent())
+                .addOnSuccessListener {
+                    getPrefs(applicationContext).edit()
+                        .putLong(PREFS_KEY_LAST_ADD_AT, System.currentTimeMillis())
+                        .apply()
+                    Log.i(TAG, "addGeofences: SUCCESS — geofences registered with Play Services")
+                    promise.resolve(true)
+                }
+                .addOnFailureListener { e ->
+                    Log.e(TAG, "addGeofences: FAILURE — ${e.message}", e)
+                    promise.resolve(false)
                 }
-            )
         } catch (e: Exception) {
-            Log.e(TAG, "💥 EXCEÇÃO em start():")
-            Log.e(TAG, "   └─ Message: ${e.message}")
-            Log.e(TAG, "   └─ StackTrace: ${e.stackTraceToString()}")
-            promise.reject("GEOFENCE_ERROR", e.message)
+            Log.e(TAG, "addGeofences: exception", e)
+            promise.reject(e)
         }
     }
 
-    override fun stop(promise: Promise) {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "⏹️ STOP() CHAMADO")
-        Log.d(TAG, "════════════════════════════════════════")
-        try {
-            Log.d(TAG, "🔄 Chamando RegionManager.removeAllGeofences()...")
-            RegionManager.removeAllGeofences(reactApplicationContext)
-            Log.d(TAG, "✅ STOP() SUCESSO - Promise resolvida")
-            promise.resolve(null)
-        } catch (e: Exception) {
-            Log.e(TAG, "💥 EXCEÇÃO em stop():")
-            Log.e(TAG, "   └─ Message: ${e.message}")
-            Log.e(TAG, "   └─ StackTrace: ${e.stackTraceToString()}")
-            promise.reject("GEOFENCE_ERROR", e.message)
+    private fun saveDetailsToPrefs(context: Context) {
+        synchronized(GeofenceManagerModule.geofenceDetailsMap) {
+            val arr = JSONArray()
+            GeofenceManagerModule.geofenceDetailsMap.values.forEach { d ->
+                arr.put(JSONObject().apply {
+                    put("id", d.id)
+                    put("name", d.name ?: "")
+                    put("latitude", d.latitude)
+                    put("longitude", d.longitude)
+                    put("radius", d.radius.toDouble())
+                })
+            }
+            getPrefs(context).edit().putString(PREFS_KEY_DETAILS, arr.toString()).apply()
         }
     }
 
-    override fun isActive(promise: Promise) {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "❓ IS_ACTIVE() CHAMADO")
-        Log.d(TAG, "════════════════════════════════════════")
-        try {
-            val active = RegionManager.isActive(reactApplicationContext)
-            Log.d(TAG, "📊 Resultado: active=$active")
-            Log.d(TAG, "✅ IS_ACTIVE() SUCESSO - Promise resolvida")
-            promise.resolve(active)
-        } catch (e: Exception) {
-            Log.e(TAG, "💥 EXCEÇÃO em isActive():")
-            Log.e(TAG, "   └─ Message: ${e.message}")
-            promise.reject("GEOFENCE_ERROR", e.message)
+    override fun removeAllGeofences(promise: Promise) {
+        Log.i(TAG, "removeAllGeofences: start")
+        synchronized(GeofenceManagerModule.geofenceNames) {
+            GeofenceManagerModule.geofenceNames.clear()
+            GeofenceManagerModule.geofenceDetailsMap.clear()
         }
-    }
-
-    override fun getActiveRegions(promise: Promise) {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "📋 GET_ACTIVE_REGIONS() CHAMADO")
-        Log.d(TAG, "════════════════════════════════════════")
-        try {
-            val regions = RegionManager.getRegions(reactApplicationContext)
-            Log.d(TAG, "📊 Encontradas ${regions.size} região(ões) ativas")
-
-            val result: WritableArray = Arguments.createArray()
-
-            for (region in regions) {
-                Log.d(TAG, "   └─ id=${region.id}, name=${region.name}")
-                Log.d(TAG, "      └─ lat=${region.latitude}, lng=${region.longitude}, radius=${region.radius}m")
-                val map = Arguments.createMap().apply {
-                    putString("id", region.id)
-                    putString("name", region.name)
-                    putString("data", region.data)
-                    putDouble("latitude", region.latitude)
-                    putDouble("longitude", region.longitude)
-                    putDouble("radius", region.radius.toDouble())
-                }
-                result.pushMap(map)
+        getPrefs(applicationContext).edit().remove(PREFS_KEY_DETAILS).apply()
+        geofencingClient.removeGeofences(getPendingIntent())
+            .addOnSuccessListener {
+                Log.i(TAG, "removeAllGeofences: SUCCESS")
+                promise.resolve(true)
             }
-
-            Log.d(TAG, "✅ GET_ACTIVE_REGIONS() SUCESSO - Promise resolvida")
-            promise.resolve(result)
-        } catch (e: Exception) {
-            Log.e(TAG, "💥 EXCEÇÃO em getActiveRegions():")
-            Log.e(TAG, "   └─ Message: ${e.message}")
-            promise.reject("GEOFENCE_ERROR", e.message)
-        }
-    }
-
-    private fun parseRegions(regions: ReadableArray): List<Region> {
-        Log.d(TAG, "🔧 parseRegions() - Parseando ${regions.size()} regiões...")
-        val list = mutableListOf<Region>()
-        for (i in 0 until regions.size()) {
-            val map = regions.getMap(i)
-            if (map == null) {
-                Log.w(TAG, "   └─ [$i] IGNORADA - map é null")
-                continue
+            .addOnFailureListener { e ->
+                Log.e(TAG, "removeAllGeofences: FAILURE — ${e.message}", e)
+                promise.resolve(false)
             }
-            val region = Region(
-                id = map.getString("id") ?: "region_$i",
-                name = map.getString("name") ?: "",
-                data = map.getString("data") ?: "",
-                latitude = map.getDouble("latitude"),
-                longitude = map.getDouble("longitude"),
-                radius = map.takeIf { it.hasKey("radius") }?.getDouble("radius")?.toFloat() ?: 100f
-            )
-            Log.d(TAG, "   └─ [$i] OK - id=${region.id}")
-            list.add(region)
-        }
-        Log.d(TAG, "🔧 parseRegions() - Concluído: ${list.size} regiões válidas")
-        return list
     }
 }

package/ios/GeofenceManager.mm

@@ -1,21 +1,21 @@
-#import "GeofenceManager.h"
-
-@implementation GeofenceManager
-- (NSNumber *)multiply:(double)a b:(double)b {
-    NSNumber *result = @(a * b);
-
-    return result;
-}
-
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
-    (const facebook::react::ObjCTurboModule::InitParams &)params
-{
-    return std::make_shared<facebook::react::NativeGeofenceManagerSpecJSI>(params);
-}
-
-+ (NSString *)moduleName
-{
-  return @"GeofenceManager";
-}
-
-@end
+#import "GeofenceManager.h"
+
+@implementation GeofenceManager
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeGeofenceManagerSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"GeofenceManager";
+}
+
+- (NSNumber *)multiply:(double)a b:(double)b
+{
+  return @(a * b);
+}
+
+@end

package/lib/module/NativeGeofenceManager.js

@@ -1,11 +1,5 @@
 "use strict";
 
 import { TurboModuleRegistry } from 'react-native';
-const NativeModule = TurboModuleRegistry.get('GeofenceManager');
-if (NativeModule) {
-  console.log('✅ react-native-geofence-manager: Native module linked successfully');
-} else {
-  console.warn('❌ react-native-geofence-manager: Native module not found. Make sure you rebuilt the app after installing the package.');
-}
-export default NativeModule;
+export default TurboModuleRegistry.getEnforcing('GeofenceManager');
 //# sourceMappingURL=NativeGeofenceManager.js.map

package/lib/module/NativeGeofenceManager.js.map

@@ -1 +1 @@
-{"version":3,"names":["TurboModuleRegistry","NativeModule","get","console","log","warn"],"sourceRoot":"..\\..\\src","sources":["NativeGeofenceManager.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAuBpE,MAAMC,YAAY,GAAGD,mBAAmB,CAACE,GAAG,CAAO,iBAAiB,CAAC;AAErE,IAAID,YAAY,EAAE;EAChBE,OAAO,CAACC,GAAG,CAAC,oEAAoE,CAAC;AACnF,CAAC,MAAM;EACLD,OAAO,CAACE,IAAI,CACV,uHACF,CAAC;AACH;AAEA,eAAeJ,YAAY","ignoreList":[]}
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"..\\..\\src","sources":["NativeGeofenceManager.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAQpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,iBAAiB,CAAC","ignoreList":[]}

package/lib/module/geofenceDebugLog.js

@@ -0,0 +1,22 @@
+"use strict";
+
+/**
+ * Logs de diagnóstico da lib. Aparecem no Metro e no Logcat (Android) com filtro "GeofenceManager".
+ */
+const TAG = '[GeofenceManager]';
+function safeStringify(data) {
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return String(data);
+  }
+}
+export function geofenceDebugLog(step, data) {
+  const line = data !== undefined ? `${TAG} ${step} ${safeStringify(data)}` : `${TAG} ${step}`;
+  console.log(line);
+}
+export function geofenceDebugWarn(step, data) {
+  const line = data !== undefined ? `${TAG} ${step} ${safeStringify(data)}` : `${TAG} ${step}`;
+  console.warn(line);
+}
+//# sourceMappingURL=geofenceDebugLog.js.map

package/lib/module/geofenceDebugLog.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TAG","safeStringify","data","JSON","stringify","String","geofenceDebugLog","step","line","undefined","console","log","geofenceDebugWarn","warn"],"sourceRoot":"..\\..\\src","sources":["geofenceDebugLog.ts"],"mappings":";;AAAA;AACA;AACA;AACA,MAAMA,GAAG,GAAG,mBAAmB;AAE/B,SAASC,aAAaA,CAACC,IAAa,EAAU;EAC5C,IAAI;IACF,OAAOC,IAAI,CAACC,SAAS,CAACF,IAAI,CAAC;EAC7B,CAAC,CAAC,MAAM;IACN,OAAOG,MAAM,CAACH,IAAI,CAAC;EACrB;AACF;AAEA,OAAO,SAASI,gBAAgBA,CAACC,IAAY,EAAEL,IAAc,EAAQ;EACnE,MAAMM,IAAI,GACRN,IAAI,KAAKO,SAAS,GACd,GAAGT,GAAG,IAAIO,IAAI,IAAIN,aAAa,CAACC,IAAI,CAAC,EAAE,GACvC,GAAGF,GAAG,IAAIO,IAAI,EAAE;EACtBG,OAAO,CAACC,GAAG,CAACH,IAAI,CAAC;AACnB;AAEA,OAAO,SAASI,iBAAiBA,CAACL,IAAY,EAAEL,IAAc,EAAQ;EACpE,MAAMM,IAAI,GACRN,IAAI,KAAKO,SAAS,GACd,GAAGT,GAAG,IAAIO,IAAI,IAAIN,aAAa,CAACC,IAAI,CAAC,EAAE,GACvC,GAAGF,GAAG,IAAIO,IAAI,EAAE;EACtBG,OAAO,CAACG,IAAI,CAACL,IAAI,CAAC;AACpB","ignoreList":[]}

package/lib/module/index.js

@@ -1,42 +1,86 @@
 "use strict";
 
-import NativeGeofence from './NativeGeofenceManager';
-import { AppRegistry, NativeEventEmitter, Platform } from 'react-native';
-const emitter = new NativeEventEmitter();
-const MAX_REGIONS = 100;
-const notLinkedError = () => Promise.reject(new Error('❌ react-native-geofence-manager: Native module not linked. Rebuild your app.'));
-export const GeofenceManager = {
-  start: (regions, options) => {
-    if (!NativeGeofence) return notLinkedError();
-    if (regions.length > MAX_REGIONS) {
-      return Promise.reject(new Error(`Limite máximo de ${MAX_REGIONS} regiões excedido. Recebido: ${regions.length}`));
-    }
-    return NativeGeofence.start(regions, options ?? {}).then(() => {
-      console.log('✅ react-native-geofence-manager: Geofencing started successfully');
-    });
-  },
-  stop: () => {
-    if (!NativeGeofence) return notLinkedError();
-    return NativeGeofence.stop().then(() => {
-      console.log('🛑 react-native-geofence-manager: Geofencing stopped');
+import { AppRegistry, DeviceEventEmitter } from 'react-native';
+import NativeGeofenceManager from "./NativeGeofenceManager.js";
+import { geofenceDebugLog, geofenceDebugWarn } from "./geofenceDebugLog.js";
+const EVENT_NAME = 'onGeofenceTransition';
+
+/** Nome da headless task para eventos de geofence (app morto/background). Deve ser usado com registerGeofenceHeadlessTask no index do app. */
+export const GEOFENCE_HEADLESS_TASK_NAME = 'GeofenceManagerTransition';
+export function addGeofenceEventListener(callback) {
+  geofenceDebugLog('JS: addGeofenceEventListener — registering listener', {
+    eventName: EVENT_NAME
+  });
+  const subscription = DeviceEventEmitter.addListener(EVENT_NAME, payload => {
+    geofenceDebugLog('JS: addGeofenceEventListener — event received', payload);
+    callback(payload);
+  });
+  return () => {
+    geofenceDebugLog('JS: addGeofenceEventListener — unsubscribed');
+    subscription.remove();
+  };
+}
+export function onGeofenceEvent(callback) {
+  return addGeofenceEventListener(callback);
+}
+
+/**
+ * Registra o handler da headless task para quando o app é acordado por um evento de geofence
+ * (app morto ou em background). Deve ser chamado no index do app, antes de AppRegistry.registerComponent.
+ *
+ * @example
+ * // index.js
+ * import { AppRegistry } from 'react-native';
+ * import { registerGeofenceHeadlessTask } from 'react-native-geofence-manager';
+ * import App from './App';
+ * import { name as appName } from './app.json';
+ *
+ * registerGeofenceHeadlessTask((event) => {
+ *   console.log('Geofence (headless):', event.geofenceId, event.event);
+ * });
+ *
+ * AppRegistry.registerComponent(appName, () => App);
+ */
+export function registerGeofenceHeadlessTask(callback) {
+  geofenceDebugLog('JS: registerGeofenceHeadlessTask — registering', {
+    taskName: GEOFENCE_HEADLESS_TASK_NAME
+  });
+  AppRegistry.registerHeadlessTask(GEOFENCE_HEADLESS_TASK_NAME, () => data => {
+    geofenceDebugLog('JS: headless task invoked', data);
+    return Promise.resolve(callback(data));
+  });
+}
+const addGeofences = async geofences => {
+  geofenceDebugLog('JS: addGeofences — calling native', {
+    count: geofences.length,
+    ids: geofences.map(g => g.id)
+  });
+  try {
+    const ok = await NativeGeofenceManager.addGeofences(geofences);
+    geofenceDebugLog('JS: addGeofences — native result', {
+      success: ok
     });
-  },
-  onEnter: cb => emitter.addListener('onEnter', cb),
-  onExit: cb => emitter.addListener('onExit', cb),
-  onDwell: cb => emitter.addListener('onDwell', cb),
-  registerBackgroundHandler: handler => {
-    if (Platform.OS !== 'android') {
-      return;
+    if (!ok) {
+      geofenceDebugWarn('JS: addGeofences — native returned false (empty list, Geofencing API failure, or permissions)');
     }
-    AppRegistry.registerHeadlessTask('GeofenceHeadlessTask', () => handler);
-  },
-  isActive: () => {
-    if (!NativeGeofence) return Promise.resolve(false);
-    return NativeGeofence.isActive();
-  },
-  getActiveRegions: () => {
-    if (!NativeGeofence) return Promise.resolve([]);
-    return NativeGeofence.getActiveRegions();
+    return ok;
+  } catch (e) {
+    geofenceDebugWarn('JS: addGeofences — threw (TurboModule missing or bridge error)', e);
+    throw e;
+  }
+};
+const removeAllGeofences = async () => {
+  geofenceDebugLog('JS: removeAllGeofences — calling native');
+  try {
+    const ok = await NativeGeofenceManager.removeAllGeofences();
+    geofenceDebugLog('JS: removeAllGeofences — native result', {
+      success: ok
+    });
+    return ok;
+  } catch (e) {
+    geofenceDebugWarn('JS: removeAllGeofences — threw', e);
+    throw e;
   }
 };
+export { addGeofences, removeAllGeofences };
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeGeofence","AppRegistry","NativeEventEmitter","Platform","emitter","MAX_REGIONS","notLinkedError","Promise","reject","Error","GeofenceManager","start","regions","options","length","then","console","log","stop","onEnter","cb","addListener","onExit","onDwell","registerBackgroundHandler","handler","OS","registerHeadlessTask","isActive","resolve","getActiveRegions"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,cAAc,MAGd,yBAAyB;AAChC,SAASC,WAAW,EAAEC,kBAAkB,EAAEC,QAAQ,QAAQ,cAAc;AAExE,MAAMC,OAAO,GAAG,IAAIF,kBAAkB,CAAC,CAAC;AAExC,MAAMG,WAAW,GAAG,GAAG;AAmBvB,MAAMC,cAAc,GAAGA,CAAA,KACrBC,OAAO,CAACC,MAAM,CACZ,IAAIC,KAAK,CACP,8EACF,CACF,CAAC;AAEH,OAAO,MAAMC,eAAe,GAAG;EAC7BC,KAAK,EAAEA,CAACC,OAAiB,EAAEC,OAAyB,KAAoB;IACtE,IAAI,CAACb,cAAc,EAAE,OAAOM,cAAc,CAAC,CAAC;IAC5C,IAAIM,OAAO,CAACE,MAAM,GAAGT,WAAW,EAAE;MAChC,OAAOE,OAAO,CAACC,MAAM,CACnB,IAAIC,KAAK,CACP,oBAAoBJ,WAAW,gCAAgCO,OAAO,CAACE,MAAM,EAC/E,CACF,CAAC;IACH;IACA,OAAOd,cAAc,CAACW,KAAK,CAACC,OAAO,EAAEC,OAAO,IAAI,CAAC,CAAC,CAAC,CAACE,IAAI,CAAC,MAAM;MAC7DC,OAAO,CAACC,GAAG,CAAC,kEAAkE,CAAC;IACjF,CAAC,CAAC;EACJ,CAAC;EAEDC,IAAI,EAAEA,CAAA,KAAqB;IACzB,IAAI,CAAClB,cAAc,EAAE,OAAOM,cAAc,CAAC,CAAC;IAC5C,OAAON,cAAc,CAACkB,IAAI,CAAC,CAAC,CAACH,IAAI,CAAC,MAAM;MACtCC,OAAO,CAACC,GAAG,CAAC,sDAAsD,CAAC;IACrE,CAAC,CAAC;EACJ,CAAC;EAEDE,OAAO,EAAGC,EAAyC,IACjDhB,OAAO,CAACiB,WAAW,CAAC,SAAS,EAAED,EAAS,CAAC;EAE3CE,MAAM,EAAGF,EAAyC,IAChDhB,OAAO,CAACiB,WAAW,CAAC,QAAQ,EAAED,EAAS,CAAC;EAE1CG,OAAO,EAAGH,EAAyC,IACjDhB,OAAO,CAACiB,WAAW,CAAC,SAAS,EAAED,EAAS,CAAC;EAE3CI,yBAAyB,EAAGC,OAAkC,IAAW;IACvE,IAAItB,QAAQ,CAACuB,EAAE,KAAK,SAAS,EAAE;MAC7B;IACF;IACAzB,WAAW,CAAC0B,oBAAoB,CAAC,sBAAsB,EAAE,MAAMF,OAAO,CAAC;EACzE,CAAC;EAEDG,QAAQ,EAAEA,CAAA,KAAwB;IAChC,IAAI,CAAC5B,cAAc,EAAE,OAAOO,OAAO,CAACsB,OAAO,CAAC,KAAK,CAAC;IAClD,OAAO7B,cAAc,CAAC4B,QAAQ,CAAC,CAAC;EAClC,CAAC;EAEDE,gBAAgB,EAAEA,CAAA,KAAyB;IACzC,IAAI,CAAC9B,cAAc,EAAE,OAAOO,OAAO,CAACsB,OAAO,CAAC,EAAE,CAAC;IAC/C,OAAO7B,cAAc,CAAC8B,gBAAgB,CAAC,CAAC;EAC1C;AACF,CAAC","ignoreList":[]}
+{"version":3,"names":["AppRegistry","DeviceEventEmitter","NativeGeofenceManager","geofenceDebugLog","geofenceDebugWarn","EVENT_NAME","GEOFENCE_HEADLESS_TASK_NAME","addGeofenceEventListener","callback","eventName","subscription","addListener","payload","remove","onGeofenceEvent","registerGeofenceHeadlessTask","taskName","registerHeadlessTask","data","Promise","resolve","addGeofences","geofences","count","length","ids","map","g","id","ok","success","e","removeAllGeofences"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,SACEA,WAAW,EACXC,kBAAkB,QAEb,cAAc;AACrB,OAAOC,qBAAqB,MAAM,4BAAyB;AAC3D,SAASC,gBAAgB,EAAEC,iBAAiB,QAAQ,uBAAoB;AASxE,MAAMC,UAAU,GAAG,sBAAsB;;AAEzC;AACA,OAAO,MAAMC,2BAA2B,GAAG,2BAA2B;AAEtE,OAAO,SAASC,wBAAwBA,CACtCC,QAAwC,EAC5B;EACZL,gBAAgB,CAAC,qDAAqD,EAAE;IACtEM,SAAS,EAAEJ;EACb,CAAC,CAAC;EACF,MAAMK,YAA+B,GAAGT,kBAAkB,CAACU,WAAW,CACpEN,UAAU,EACTO,OAAgB,IAAK;IACpBT,gBAAgB,CAAC,+CAA+C,EAAES,OAAO,CAAC;IAC1EJ,QAAQ,CAACI,OAAwB,CAAC;EACpC,CACF,CAAC;EACD,OAAO,MAAM;IACXT,gBAAgB,CAAC,6CAA6C,CAAC;IAC/DO,YAAY,CAACG,MAAM,CAAC,CAAC;EACvB,CAAC;AACH;AAEA,OAAO,SAASC,eAAeA,CAC7BN,QAAwC,EAC5B;EACZ,OAAOD,wBAAwB,CAACC,QAAQ,CAAC;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASO,4BAA4BA,CAC1CP,QAAwC,EAClC;EACNL,gBAAgB,CAAC,gDAAgD,EAAE;IACjEa,QAAQ,EAAEV;EACZ,CAAC,CAAC;EACFN,WAAW,CAACiB,oBAAoB,CAC9BX,2BAA2B,EAC3B,MAAOY,IAAa,IAAK;IACvBf,gBAAgB,CAAC,2BAA2B,EAAEe,IAAI,CAAC;IACnD,OAAOC,OAAO,CAACC,OAAO,CAACZ,QAAQ,CAACU,IAAqB,CAAC,CAAC;EACzD,CACF,CAAC;AACH;AAEA,MAAMG,YAAY,GAAG,MACnBC,SAA0B,IACL;EACrBnB,gBAAgB,CAAC,mCAAmC,EAAE;IACpDoB,KAAK,EAAED,SAAS,CAACE,MAAM;IACvBC,GAAG,EAAEH,SAAS,CAACI,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAACC,EAAE;EAChC,CAAC,CAAC;EACF,IAAI;IACF,MAAMC,EAAE,GAAG,MAAM3B,qBAAqB,CAACmB,YAAY,CAACC,SAAS,CAAC;IAC9DnB,gBAAgB,CAAC,kCAAkC,EAAE;MAAE2B,OAAO,EAAED;IAAG,CAAC,CAAC;IACrE,IAAI,CAACA,EAAE,EAAE;MACPzB,iBAAiB,CACf,+FACF,CAAC;IACH;IACA,OAAOyB,EAAE;EACX,CAAC,CAAC,OAAOE,CAAC,EAAE;IACV3B,iBAAiB,CAAC,gEAAgE,EAAE2B,CAAC,CAAC;IACtF,MAAMA,CAAC;EACT;AACF,CAAC;AAED,MAAMC,kBAAkB,GAAG,MAAAA,CAAA,KAA8B;EACvD7B,gBAAgB,CAAC,yCAAyC,CAAC;EAC3D,IAAI;IACF,MAAM0B,EAAE,GAAG,MAAM3B,qBAAqB,CAAC8B,kBAAkB,CAAC,CAAC;IAC3D7B,gBAAgB,CAAC,wCAAwC,EAAE;MAAE2B,OAAO,EAAED;IAAG,CAAC,CAAC;IAC3E,OAAOA,EAAE;EACX,CAAC,CAAC,OAAOE,CAAC,EAAE;IACV3B,iBAAiB,CAAC,gCAAgC,EAAE2B,CAAC,CAAC;IACtD,MAAMA,CAAC;EACT;AACF,CAAC;AAED,SAASV,YAAY,EAAEW,kBAAkB","ignoreList":[]}

package/lib/module/models/GeofenceEvent.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=GeofenceEvent.js.map

package/lib/module/models/GeofenceEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"..\\..\\..\\src","sources":["models/GeofenceEvent.ts"],"mappings":"","ignoreList":[]}

package/lib/module/models/GeofenceEventType.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=GeofenceEventType.js.map

package/lib/module/models/GeofenceEventType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"..\\..\\..\\src","sources":["models/GeofenceEventType.ts"],"mappings":"","ignoreList":[]}