react-native-geofence-manager 0.1.0-beta.12 → 0.1.0-beta.14

package/README.md

@@ -115,6 +115,22 @@ Para geofences confiáveis é necessário **localização** (fina ou aproximada)
 
 ---
 
+## Depuração (logs)
+
+A lib emite logs em cada etapa para localizar falhas (SDK nativo + JS).
+
+**Android (Logcat)** — filtre pela tag:
+
+```text
+adb logcat -s GeofenceManager
+```
+
+Você verá, entre outros: inicialização do módulo, `addGeofences` (sucesso/falha do Play Services), `BroadcastReceiver` (transição, foreground vs headless), `HeadlessTaskService` e erros de reflexão.
+
+**JavaScript** — mensagens com prefixo `[GeofenceManager]` no console (Metro) e também no Logcat como `ReactNativeJS` ao rodar no dispositivo.
+
+---
+
 ## App de exemplo
 
 Na raiz do repositório:

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

@@ -4,6 +4,7 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.os.Build
+import android.util.Log
 import android.os.Handler
 import android.os.Looper
 import com.facebook.react.HeadlessJsTaskService
@@ -16,36 +17,71 @@ import com.google.android.gms.location.GeofencingEvent
 
 class GeofenceBroadcastReceiver : BroadcastReceiver() {
 
+    companion object {
+        private const val TAG = "GeofenceManager"
+    }
+
     override fun onReceive(context: Context?, intent: Intent?) {
-        if (context == null || intent == null) return
-        if (intent.action != GeofenceManagerModule.GEOFENCE_ACTION) return
+        Log.i(TAG, "BroadcastReceiver.onReceive: invoked action=${intent?.action}")
+        if (context == null || intent == null) {
+            Log.w(TAG, "BroadcastReceiver.onReceive: abort — null context or intent")
+            return
+        }
+        if (intent.action != GeofenceManagerModule.GEOFENCE_ACTION) {
+            Log.w(TAG, "BroadcastReceiver.onReceive: wrong action, expected ${GeofenceManagerModule.GEOFENCE_ACTION}")
+            return
+        }
 
-        val geofencingEvent = GeofencingEvent.fromIntent(intent) ?: return
-        if (geofencingEvent.hasError()) return
+        val geofencingEvent = GeofencingEvent.fromIntent(intent)
+        if (geofencingEvent == null) {
+            Log.e(TAG, "BroadcastReceiver.onReceive: GeofencingEvent.fromIntent returned null")
+            return
+        }
+        if (geofencingEvent.hasError()) {
+            Log.e(TAG, "BroadcastReceiver.onReceive: Geofencing error code=${geofencingEvent.errorCode}")
+            return
+        }
 
-        if (GeofenceManagerModule.isWithinGracePeriod(context)) return
+        if (GeofenceManagerModule.isWithinGracePeriod(context)) {
+            Log.i(TAG, "BroadcastReceiver.onReceive: skipped — within grace period after addGeofences")
+            return
+        }
 
         val transition = geofencingEvent.geofenceTransition
         val eventName = when (transition) {
             Geofence.GEOFENCE_TRANSITION_ENTER -> "enter"
             Geofence.GEOFENCE_TRANSITION_EXIT -> "exit"
             Geofence.GEOFENCE_TRANSITION_DWELL -> "dwell"
-            else -> return
+            else -> {
+                Log.w(TAG, "BroadcastReceiver.onReceive: unknown transition=$transition")
+                return
+            }
         }
+        Log.i(TAG, "BroadcastReceiver.onReceive: transition=$eventName")
 
-        val triggeringGeofences = geofencingEvent.triggeringGeofences ?: return
-        if (triggeringGeofences.isEmpty()) return
+        val triggeringGeofences = geofencingEvent.triggeringGeofences
+        if (triggeringGeofences == null || triggeringGeofences.isEmpty()) {
+            Log.w(TAG, "BroadcastReceiver.onReceive: no triggering geofences")
+            return
+        }
 
         val reactContext = GeofenceManagerModule.reactContextRef
         val timestamp = System.currentTimeMillis().toDouble()
         val isForeground = reactContext != null && reactContext.hasActiveReactInstance()
+        Log.i(
+            TAG,
+            "BroadcastReceiver.onReceive: ids=${triggeringGeofences.map { it.requestId }} isForeground=$isForeground hasReactContextRef=${reactContext != null}"
+        )
 
         if (isForeground) {
             val ctx = reactContext!!
             val geofenceIds = triggeringGeofences.map { it.requestId }
             val eventNameForRunnable = eventName
             Handler(Looper.getMainLooper()).postDelayed({
-                if (!ctx.hasActiveReactInstance()) return@postDelayed
+                if (!ctx.hasActiveReactInstance()) {
+                    Log.w(TAG, "BroadcastReceiver: foreground path — React instance gone after delay, skipping emit")
+                    return@postDelayed
+                }
                 try {
                     val emitter = ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                     for (geofenceId in geofenceIds) {
@@ -61,13 +97,17 @@ class GeofenceBroadcastReceiver : BroadcastReceiver() {
                                 putDouble("radius", it.radius.toDouble())
                             }
                         }
+                        Log.i(TAG, "BroadcastReceiver: emitting onGeofenceTransition id=$geofenceId event=$eventNameForRunnable")
                         emitter.emit("onGeofenceTransition", params)
                     }
-                } catch (_: Exception) { }
+                } catch (e: Exception) {
+                    Log.e(TAG, "BroadcastReceiver: emit to JS failed", e)
+                }
             }, 50)
             return
         }
 
+        Log.i(TAG, "BroadcastReceiver: background/headless path — starting GeofenceHeadlessTaskService")
         val appContext = context.applicationContext
         HeadlessJsTaskService.acquireWakeLockNow(appContext)
         for (geofence in triggeringGeofences) {
@@ -76,10 +116,16 @@ class GeofenceBroadcastReceiver : BroadcastReceiver() {
                 putExtra(GeofenceHeadlessTaskService.EXTRA_EVENT, eventName)
                 putExtra(GeofenceHeadlessTaskService.EXTRA_TIMESTAMP, timestamp)
             }
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                appContext.startForegroundService(serviceIntent)
-            } else {
-                appContext.startService(serviceIntent)
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    appContext.startForegroundService(serviceIntent)
+                    Log.i(TAG, "BroadcastReceiver: startForegroundService for id=${geofence.requestId}")
+                } else {
+                    appContext.startService(serviceIntent)
+                    Log.i(TAG, "BroadcastReceiver: startService for id=${geofence.requestId}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "BroadcastReceiver: failed to start headless service", e)
             }
         }
     }

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

@@ -5,6 +5,7 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.Intent
 import android.os.Build
+import android.util.Log
 import com.facebook.react.HeadlessJsTaskService
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.jstasks.HeadlessJsTaskConfig
@@ -18,13 +19,21 @@ class GeofenceHeadlessTaskService : HeadlessJsTaskService() {
      * startForeground() é chamado para que o sistema inicie o serviço mesmo em background (dwell/exit).
      */
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        Log.i(TAG, "HeadlessTaskService.onStartCommand extras=${intent?.extras}")
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             ensureNotificationChannel()
             val notification = buildNotification(intent)
             startForeground(NOTIFICATION_ID, notification)
+            Log.d(TAG, "HeadlessTaskService: startForeground done")
+        }
+        val taskConfig = getTaskConfig(intent)
+        if (taskConfig == null) {
+            Log.e(TAG, "HeadlessTaskService: getTaskConfig returned null — check EXTRA_GEOFENCE_ID / EXTRA_EVENT")
+            return START_NOT_STICKY
         }
-        val taskConfig = getTaskConfig(intent) ?: return START_NOT_STICKY
         val ctx = reactContext
+        val hasInstance = ctx?.hasActiveReactInstance() == true
+        Log.i(TAG, "HeadlessTaskService: hasActiveReactInstance=$hasInstance")
         if (ctx != null && !ctx.hasActiveReactInstance()) {
             HeadlessJsTaskService.acquireWakeLockNow(this)
             try {
@@ -34,21 +43,32 @@ class GeofenceHeadlessTaskService : HeadlessJsTaskService() {
                 )
                 method.isAccessible = true
                 method.invoke(this, taskConfig)
-            } catch (_: Exception) {
+                Log.i(TAG, "HeadlessTaskService: createReactContextAndScheduleTask invoked OK")
+            } catch (e: Exception) {
+                Log.e(TAG, "HeadlessTaskService: reflection createReactContextAndScheduleTask failed", e)
                 return super.onStartCommand(intent, flags, startId)
             }
             return START_REDELIVER_INTENT
         }
+        Log.i(TAG, "HeadlessTaskService: delegating to super.onStartCommand")
         return super.onStartCommand(intent, flags, startId)
     }
 
     override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
-        if (intent == null) return null
-        val geofenceId = intent.getStringExtra(EXTRA_GEOFENCE_ID) ?: return null
-        val event = intent.getStringExtra(EXTRA_EVENT) ?: return null
+        if (intent == null) {
+            Log.w(TAG, "getTaskConfig: null intent")
+            return null
+        }
+        val geofenceId = intent.getStringExtra(EXTRA_GEOFENCE_ID)
+        val event = intent.getStringExtra(EXTRA_EVENT)
+        if (geofenceId == null || event == null) {
+            Log.e(TAG, "getTaskConfig: missing geofenceId or event (id=$geofenceId event=$event)")
+            return null
+        }
         val timestamp = intent.getDoubleExtra(EXTRA_TIMESTAMP, 0.0)
 
         val details = GeofenceManagerModule.getGeofenceDetails(this, geofenceId)
+        Log.i(TAG, "getTaskConfig: task=${GeofenceManagerModule.GEOFENCE_HEADLESS_TASK_NAME} id=$geofenceId event=$event")
         val data = Arguments.createMap().apply {
             putString("geofenceId", geofenceId)
             putString("event", event)
@@ -90,6 +110,7 @@ class GeofenceHeadlessTaskService : HeadlessJsTaskService() {
     }
 
     companion object {
+        private const val TAG = "GeofenceManager"
         private const val CHANNEL_ID = "geofence_manager_channel"
         private const val NOTIFICATION_ID = 9001
         const val EXTRA_GEOFENCE_ID = "geofenceId"

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

@@ -5,6 +5,7 @@ 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.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
@@ -20,6 +21,7 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
     NativeGeofenceManagerSpec(reactContext) {
 
     companion object {
+        private const val TAG = "GeofenceManager"
         const val NAME = "GeofenceManager"
         const val GEOFENCE_ACTION = "com.geofencemanager.GEOFENCE_TRANSITION"
         const val GEOFENCE_HEADLESS_TASK_NAME = "GeofenceManagerTransition"
@@ -70,7 +72,9 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
                         geofenceDetailsMap[d.id] = d
                         d.name?.let { geofenceNames[d.id] = it }
                     }
-                } catch (_: Exception) { }
+                } catch (e: Exception) {
+                    Log.w(TAG, "loadDetailsFromPrefs failed", e)
+                }
             }
         }
 
@@ -84,11 +88,15 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
     }
 
     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)")
         }
     }
 
@@ -98,7 +106,11 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
     private var geofencePendingIntent: PendingIntent? = null
 
     private fun getPendingIntent(): PendingIntent {
-        geofencePendingIntent?.let { return it }
+        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)
@@ -116,11 +128,20 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
     override fun getName(): String = NAME
 
     override fun addGeofences(geofences: ReadableArray, promise: Promise) {
+        Log.i(TAG, "addGeofences: start, arraySize=${geofences.size()}")
         try {
             val list = mutableListOf<Geofence>()
             for (i in 0 until geofences.size()) {
-                val item: ReadableMap = geofences.getMap(i) ?: continue
-                val id = item.getString("id") ?: continue
+                val item = geofences.getMap(i)
+                if (item == null) {
+                    Log.w(TAG, "addGeofences: index $i skipped (null map)")
+                    continue
+                }
+                val id = item.getString("id")
+                if (id == null) {
+                    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")
@@ -140,8 +161,10 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
                         )
                         .build()
                 )
+                Log.i(TAG, "addGeofences: parsed geofence id=$id lat=$lat lng=$lng radius=$radius")
             }
             if (list.isEmpty()) {
+                Log.e(TAG, "addGeofences: no valid geofences — resolving false (check id/latitude/longitude)")
                 promise.resolve(false)
                 return
             }
@@ -150,15 +173,21 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
                 .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 { promise.resolve(false) }
+                .addOnFailureListener { e ->
+                    Log.e(TAG, "addGeofences: FAILURE — ${e.message}", e)
+                    promise.resolve(false)
+                }
         } catch (e: Exception) {
+            Log.e(TAG, "addGeofences: exception", e)
             promise.reject(e)
         }
     }
@@ -180,13 +209,20 @@ class GeofenceManagerModule(reactContext: ReactApplicationContext) :
     }
 
     override fun removeAllGeofences(promise: Promise) {
+        Log.i(TAG, "removeAllGeofences: start")
         synchronized(GeofenceManagerModule.geofenceNames) {
             GeofenceManagerModule.geofenceNames.clear()
             GeofenceManagerModule.geofenceDetailsMap.clear()
         }
         getPrefs(applicationContext).edit().remove(PREFS_KEY_DETAILS).apply()
         geofencingClient.removeGeofences(getPendingIntent())
-            .addOnSuccessListener { promise.resolve(true) }
-            .addOnFailureListener { promise.resolve(false) }
+            .addOnSuccessListener {
+                Log.i(TAG, "removeAllGeofences: SUCCESS")
+                promise.resolve(true)
+            }
+            .addOnFailureListener { e ->
+                Log.e(TAG, "removeAllGeofences: FAILURE — ${e.message}", e)
+                promise.resolve(false)
+            }
     }
 }

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

@@ -2,13 +2,23 @@
 
 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) {
-  const subscription = DeviceEventEmitter.addListener(EVENT_NAME, payload => callback(payload));
-  return () => subscription.remove();
+  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);
@@ -32,13 +42,45 @@ export function onGeofenceEvent(callback) {
  * AppRegistry.registerComponent(appName, () => App);
  */
 export function registerGeofenceHeadlessTask(callback) {
-  AppRegistry.registerHeadlessTask(GEOFENCE_HEADLESS_TASK_NAME, () => data => Promise.resolve(callback(data)));
+  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 = geofences => {
-  return NativeGeofenceManager.addGeofences(geofences);
+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
+    });
+    if (!ok) {
+      geofenceDebugWarn('JS: addGeofences — native returned false (empty list, Geofencing API failure, or permissions)');
+    }
+    return ok;
+  } catch (e) {
+    geofenceDebugWarn('JS: addGeofences — threw (TurboModule missing or bridge error)', e);
+    throw e;
+  }
 };
-const removeAllGeofences = () => {
-  return NativeGeofenceManager.removeAllGeofences();
+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":["AppRegistry","DeviceEventEmitter","NativeGeofenceManager","EVENT_NAME","GEOFENCE_HEADLESS_TASK_NAME","addGeofenceEventListener","callback","subscription","addListener","payload","remove","onGeofenceEvent","registerGeofenceHeadlessTask","registerHeadlessTask","data","Promise","resolve","addGeofences","geofences","removeAllGeofences"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,SACEA,WAAW,EACXC,kBAAkB,QAEb,cAAc;AACrB,OAAOC,qBAAqB,MAAM,4BAAyB;AAS3D,MAAMC,UAAU,GAAG,sBAAsB;;AAEzC;AACA,OAAO,MAAMC,2BAA2B,GAAG,2BAA2B;AAEtE,OAAO,SAASC,wBAAwBA,CACtCC,QAAwC,EAC5B;EACZ,MAAMC,YAA+B,GAAGN,kBAAkB,CAACO,WAAW,CACpEL,UAAU,EACTM,OAAgB,IAAKH,QAAQ,CAACG,OAAwB,CACzD,CAAC;EACD,OAAO,MAAMF,YAAY,CAACG,MAAM,CAAC,CAAC;AACpC;AAEA,OAAO,SAASC,eAAeA,CAC7BL,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,SAASM,4BAA4BA,CAC1CN,QAAwC,EAClC;EACNN,WAAW,CAACa,oBAAoB,CAC9BT,2BAA2B,EAC3B,MAAOU,IAAa,IAAKC,OAAO,CAACC,OAAO,CAACV,QAAQ,CAACQ,IAAqB,CAAC,CAC1E,CAAC;AACH;AAEA,MAAMG,YAAY,GAAIC,SAA0B,IAAuB;EACrE,OAAOhB,qBAAqB,CAACe,YAAY,CAACC,SAAS,CAAC;AACtD,CAAC;AAED,MAAMC,kBAAkB,GAAGA,CAAA,KAAwB;EACjD,OAAOjB,qBAAqB,CAACiB,kBAAkB,CAAC,CAAC;AACnD,CAAC;AAED,SAASF,YAAY,EAAEE,kBAAkB","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/typescript/src/geofenceDebugLog.d.ts

@@ -0,0 +1,3 @@
+export declare function geofenceDebugLog(step: string, data?: unknown): void;
+export declare function geofenceDebugWarn(step: string, data?: unknown): void;
+//# sourceMappingURL=geofenceDebugLog.d.ts.map

package/lib/typescript/src/geofenceDebugLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geofenceDebugLog.d.ts","sourceRoot":"","sources":["../../../src/geofenceDebugLog.ts"],"names":[],"mappings":"AAaA,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAMnE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAMpE"}

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEnE,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,aAAa,GACd,MAAM,gBAAgB,CAAC;AAIxB,8IAA8I;AAC9I,eAAO,MAAM,2BAA2B,8BAA8B,CAAC;AAEvE,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GACvC,MAAM,IAAI,CAMZ;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GACvC,MAAM,IAAI,CAEZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GACvC,IAAI,CAKN;AAED,QAAA,MAAM,YAAY,GAAI,WAAW,aAAa,EAAE,KAAG,OAAO,CAAC,OAAO,CAEjE,CAAC;AAEF,QAAA,MAAM,kBAAkB,QAAO,OAAO,CAAC,OAAO,CAE7C,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEnE,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,aAAa,GACd,MAAM,gBAAgB,CAAC;AAIxB,8IAA8I;AAC9I,eAAO,MAAM,2BAA2B,8BAA8B,CAAC;AAEvE,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GACvC,MAAM,IAAI,CAeZ;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GACvC,MAAM,IAAI,CAEZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GACvC,IAAI,CAWN;AAED,QAAA,MAAM,YAAY,GAChB,WAAW,aAAa,EAAE,KACzB,OAAO,CAAC,OAAO,CAkBjB,CAAC;AAEF,QAAA,MAAM,kBAAkB,QAAa,OAAO,CAAC,OAAO,CAUnD,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-geofence-manager",
-  "version": "0.1.0-beta.12",
+  "version": "0.1.0-beta.14",
   "description": "React Native library.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/geofenceDebugLog.ts

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

package/src/index.tsx

@@ -4,6 +4,7 @@ import {
   type EventSubscription,
 } from 'react-native';
 import NativeGeofenceManager from './NativeGeofenceManager';
+import { geofenceDebugLog, geofenceDebugWarn } from './geofenceDebugLog';
 import type { GeofenceEvent, GeofenceModel } from './models/index';
 
 export type {
@@ -20,11 +21,20 @@ export const GEOFENCE_HEADLESS_TASK_NAME = 'GeofenceManagerTransition';
 export function addGeofenceEventListener(
   callback: (event: GeofenceEvent) => void
 ): () => void {
+  geofenceDebugLog('JS: addGeofenceEventListener — registering listener', {
+    eventName: EVENT_NAME,
+  });
   const subscription: EventSubscription = DeviceEventEmitter.addListener(
     EVENT_NAME,
-    (payload: unknown) => callback(payload as GeofenceEvent)
+    (payload: unknown) => {
+      geofenceDebugLog('JS: addGeofenceEventListener — event received', payload);
+      callback(payload as GeofenceEvent);
+    }
   );
-  return () => subscription.remove();
+  return () => {
+    geofenceDebugLog('JS: addGeofenceEventListener — unsubscribed');
+    subscription.remove();
+  };
 }
 
 export function onGeofenceEvent(
@@ -53,18 +63,50 @@ export function onGeofenceEvent(
 export function registerGeofenceHeadlessTask(
   callback: (event: GeofenceEvent) => void
 ): void {
+  geofenceDebugLog('JS: registerGeofenceHeadlessTask — registering', {
+    taskName: GEOFENCE_HEADLESS_TASK_NAME,
+  });
   AppRegistry.registerHeadlessTask(
     GEOFENCE_HEADLESS_TASK_NAME,
-    () => (data: unknown) => Promise.resolve(callback(data as GeofenceEvent))
+    () => (data: unknown) => {
+      geofenceDebugLog('JS: headless task invoked', data);
+      return Promise.resolve(callback(data as GeofenceEvent));
+    }
   );
 }
 
-const addGeofences = (geofences: GeofenceModel[]): Promise<boolean> => {
-  return NativeGeofenceManager.addGeofences(geofences);
+const addGeofences = async (
+  geofences: GeofenceModel[]
+): Promise<boolean> => {
+  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 });
+    if (!ok) {
+      geofenceDebugWarn(
+        'JS: addGeofences — native returned false (empty list, Geofencing API failure, or permissions)'
+      );
+    }
+    return ok;
+  } catch (e) {
+    geofenceDebugWarn('JS: addGeofences — threw (TurboModule missing or bridge error)', e);
+    throw e;
+  }
 };
 
-const removeAllGeofences = (): Promise<boolean> => {
-  return NativeGeofenceManager.removeAllGeofences();
+const removeAllGeofences = async (): Promise<boolean> => {
+  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 };