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

package/README.md

@@ -1,37 +1,173 @@
-# react-native-geofence-manager
-
-Robust manager for your geofencing areas.
-
-## Installation
-
-
-```sh
-npm install react-native-geofence-manager
-```
-
-
-## Usage
-
-
-```js
-import { multiply } from 'react-native-geofence-manager';
-
-// ...
-
-const result = multiply(3, 7);
-```
-
-
-## Contributing
-
-- [Development workflow](CONTRIBUTING.md#development-workflow)
-- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
-- [Code of conduct](CODE_OF_CONDUCT.md)
-
-## License
-
-MIT
-
----
-
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+# react-native-geofence-manager
+
+> **⚠️ Status: POC (proof of concept)**  
+> Esta biblioteca é um **protótipo experimental**. A API, o comportamento e a estabilidade podem mudar sem aviso prévio. **Não use em produção** sem avaliar riscos e fazer testes próprios.
+
+> **📱 Plataforma: apenas Android**  
+> A implementação nativa existe **somente para Android** (Google Play Services / Geofencing API). No **iOS** não há suporte funcional — não espere geofences nesta lib em dispositivos Apple.
+
+---
+
+## O que faz
+
+Permite registrar **geofences circulares** e receber eventos de **entrada**, **saída** e **permanência (dwell)** no JavaScript, inclusive quando o app está em **segundo plano** ou **fechado**, desde que a headless task esteja registrada no `index` do app.
+
+---
+
+## Instalação
+
+```sh
+npm install react-native-geofence-manager
+# ou
+yarn add react-native-geofence-manager
+```
+
+Siga o fluxo normal de autolinking do React Native. **Use apenas em projetos Android** para obter o comportamento descrito abaixo.
+
+---
+
+## Uso
+
+### 1. Registrar a headless task (obrigatório para eventos com app em background/fechado)
+
+No arquivo de entrada do app (`index.js` / `index.tsx`), **antes** de `AppRegistry.registerComponent`:
+
+```tsx
+import { AppRegistry } from 'react-native';
+import {
+  registerGeofenceHeadlessTask,
+  type GeofenceEvent,
+} from 'react-native-geofence-manager';
+import App from './App';
+import { name as appName } from './app.json';
+
+registerGeofenceHeadlessTask((event: GeofenceEvent) => {
+  // Ex.: notificação local, log, envio para API
+  console.log('Geofence (headless):', event.geofenceId, event.event);
+});
+
+AppRegistry.registerComponent(appName, () => App);
+```
+
+### 2. Adicionar geofences
+
+```tsx
+import { addGeofences } from 'react-native-geofence-manager';
+
+const ok = await addGeofences([
+  {
+    id: 'loja-1',
+    name: 'Loja centro',
+    latitude: -23.5505,
+    longitude: -46.6333,
+    radius: 150, // metros (opcional; padrão nativo ~100 m se omitido)
+  },
+]);
+// ok === true se o registro foi aceito pelo sistema
+```
+
+### 3. Listener com o app em primeiro plano
+
+```tsx
+import { addGeofenceEventListener } from 'react-native-geofence-manager';
+
+const unsubscribe = addGeofenceEventListener((event) => {
+  console.log(event.geofenceId, event.event); // 'enter' | 'exit' | 'dwell'
+});
+
+// ao desmontar:
+unsubscribe();
+```
+
+### 4. Remover todas as geofences
+
+```tsx
+import { removeAllGeofences } from 'react-native-geofence-manager';
+
+await removeAllGeofences();
+```
+
+---
+
+## Modelo de geofence (`GeofenceModel`)
+
+| Campo         | Tipo     | Obrigatório | Descrição                          |
+|---------------|----------|-------------|------------------------------------|
+| `id`          | `string` | Sim         | ID único da geofence               |
+| `latitude`    | `number` | Sim         | Latitude do centro                 |
+| `longitude`   | `number` | Sim         | Longitude do centro                |
+| `name`        | `string` | Não         | Nome exibido nos eventos           |
+| `radius`      | `number` | Não         | Raio em metros                     |
+
+---
+
+## Evento (`GeofenceEvent`)
+
+- `geofenceId` — ID da geofence  
+- `event` — `'enter' | 'exit' | 'dwell'`  
+- `timestamp`, `name`, `latitude`, `longitude`, `radius` — quando disponíveis  
+
+---
+
+## Permissões (Android)
+
+Para geofences confiáveis é necessário **localização** (fina ou aproximada) e, em geral, **localização em segundo plano** (Android 10+) se quiser eventos com o app fechado. Notificações (API 33+) dependem do seu fluxo. Consulte a documentação oficial do Android e o app de exemplo.
+
+---
+
+## 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:
+
+```sh
+yarn example start
+yarn example android
+```
+
+O diretório `example/` demonstra permissões, registro de geofences, listener e notificações locais (Notifee).
+
+---
+
+## API exportada (resumo)
+
+| Export                         | Descrição                                      |
+|--------------------------------|------------------------------------------------|
+| `addGeofences`                 | Registra uma lista de geofences                |
+| `removeAllGeofences`           | Remove todas as geofences registradas          |
+| `addGeofenceEventListener`     | Inscreve callback para eventos (foreground)    |
+| `onGeofenceEvent`              | Alias de `addGeofenceEventListener`            |
+| `registerGeofenceHeadlessTask` | Registra handler para background/app fechado   |
+| `GEOFENCE_HEADLESS_TASK_NAME`  | Nome interno da headless task                  |
+| Tipos `GeofenceModel`, `GeofenceEvent`, etc. | TypeScript                         |
+
+---
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/src/main/AndroidManifest.xml

@@ -1,16 +1,17 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
-    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
-    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
-    <uses-permission android:name="android.permission.WAKE_LOCK" />
-    
-    <application>
-        <receiver
-            android:name=".GeofenceReceiver"
-            android:exported="false" />
-            
-        <service
-            android:name=".GeofenceHeadlessTaskService"
-            android:exported="false" />
-    </application>
-</manifest>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+     <application>
+        <receiver
+            android:name=".GeofenceBroadcastReceiver"
+            android:exported="false" />
+        <service
+            android:name=".GeofenceHeadlessTaskService"
+            android:exported="false"
+            android:foregroundServiceType="location" />
+    </application>
+</manifest>

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

@@ -0,0 +1,133 @@
+package com.geofencemanager
+
+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
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.gms.location.Geofence
+import com.google.android.gms.location.GeofencingEvent
+
+class GeofenceBroadcastReceiver : BroadcastReceiver() {
+
+    companion object {
+        private const val TAG = "GeofenceManager"
+    }
+
+    override fun onReceive(context: Context?, intent: Intent?) {
+        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)
+        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)) {
+            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 -> {
+                Log.w(TAG, "BroadcastReceiver.onReceive: unknown transition=$transition")
+                return
+            }
+        }
+        Log.i(TAG, "BroadcastReceiver.onReceive: transition=$eventName")
+
+        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()) {
+                    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) {
+                        val details = GeofenceManagerModule.getGeofenceDetails(context, geofenceId)
+                        val params = Arguments.createMap().apply {
+                            putString("geofenceId", geofenceId)
+                            putString("event", eventNameForRunnable)
+                            putDouble("timestamp", timestamp)
+                            putString("name", details?.name ?: "")
+                            details?.let {
+                                putDouble("latitude", it.latitude)
+                                putDouble("longitude", it.longitude)
+                                putDouble("radius", it.radius.toDouble())
+                            }
+                        }
+                        Log.i(TAG, "BroadcastReceiver: emitting onGeofenceTransition id=$geofenceId event=$eventNameForRunnable")
+                        emitter.emit("onGeofenceTransition", params)
+                    }
+                } 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) {
+            val serviceIntent = Intent(appContext, GeofenceHeadlessTaskService::class.java).apply {
+                putExtra(GeofenceHeadlessTaskService.EXTRA_GEOFENCE_ID, geofence.requestId)
+                putExtra(GeofenceHeadlessTaskService.EXTRA_EVENT, eventName)
+                putExtra(GeofenceHeadlessTaskService.EXTRA_TIMESTAMP, timestamp)
+            }
+            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

@@ -1,7 +1,10 @@
 package com.geofencemanager
 
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
 import android.content.Intent
-import android.os.Bundle
+import android.os.Build
 import android.util.Log
 import com.facebook.react.HeadlessJsTaskService
 import com.facebook.react.bridge.Arguments
@@ -9,155 +12,109 @@ import com.facebook.react.jstasks.HeadlessJsTaskConfig
 
 class GeofenceHeadlessTaskService : HeadlessJsTaskService() {
 
-    companion object {
-        private const val TAG = "GeofenceHeadlessTask"
-    }
-
-    override fun onCreate() {
-        super.onCreate()
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "🚀 SERVICE CREATED - onCreate()")
-        Log.d(TAG, "════════════════════════════════════════")
-    }
-
+    /**
+     * Quando o app está em background/frozen, reactContext existe mas hasActiveReactInstance()
+     * retorna false e a task não roda. Nesse caso chamamos createReactContextAndScheduleTask
+     * (via reflexão) em onStartCommand para que dwell/exit sejam executados.
+     * 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.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "▶️ ON_START_COMMAND()")
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "   └─ Intent: $intent")
-        Log.d(TAG, "   └─ Flags: $flags")
-        Log.d(TAG, "   └─ StartId: $startId")
-
-        return try {
-            val result = super.onStartCommand(intent, flags, startId)
-            Log.d(TAG, "   └─ Super.onStartCommand result: $result")
-            result
-        } catch (e: Exception) {
-            Log.e(TAG, "💥 ERRO em onStartCommand:")
-            Log.e(TAG, "   └─ ${e.javaClass.simpleName}: ${e.message}")
-            Log.e(TAG, "   └─ StackTrace: ${e.stackTraceToString()}")
-            START_NOT_STICKY
+        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 ctx = reactContext
+        val hasInstance = ctx?.hasActiveReactInstance() == true
+        Log.i(TAG, "HeadlessTaskService: hasActiveReactInstance=$hasInstance")
+        if (ctx != null && !ctx.hasActiveReactInstance()) {
+            HeadlessJsTaskService.acquireWakeLockNow(this)
+            try {
+                val method = HeadlessJsTaskService::class.java.getDeclaredMethod(
+                    "createReactContextAndScheduleTask",
+                    HeadlessJsTaskConfig::class.java
+                )
+                method.isAccessible = true
+                method.invoke(this, taskConfig)
+                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 onHeadlessJsTaskStart(taskId: Int) {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "🎯 HEADLESS JS TASK STARTED!")
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "   └─ TaskId: $taskId")
-        super.onHeadlessJsTaskStart(taskId)
-    }
+    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
+        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)
+            putDouble("timestamp", timestamp)
+            putString("name", details?.name ?: "")
+            putDouble("latitude", details?.latitude ?: 0.0)
+            putDouble("longitude", details?.longitude ?: 0.0)
+            putDouble("radius", details?.radius?.toDouble() ?: 0.0)
+        }
 
-    override fun onHeadlessJsTaskFinish(taskId: Int) {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "✅ HEADLESS JS TASK FINISHED!")
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "   └─ TaskId: $taskId")
-        super.onHeadlessJsTaskFinish(taskId)
+        return HeadlessJsTaskConfig(
+            GeofenceManagerModule.GEOFENCE_HEADLESS_TASK_NAME,
+            data,
+            5000L,
+            false
+        )
     }
 
-    override fun onDestroy() {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "💀 SERVICE DESTROYED - onDestroy()")
-        Log.d(TAG, "════════════════════════════════════════")
-        super.onDestroy()
+    private fun ensureNotificationChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val channel = NotificationChannel(
+            CHANNEL_ID,
+            "Geofence",
+            NotificationManager.IMPORTANCE_LOW
+        ).apply { setShowBadge(false) }
+        (getSystemService(NOTIFICATION_SERVICE) as NotificationManager)
+            .createNotificationChannel(channel)
     }
 
-    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "🔧 GET_TASK_CONFIG() CHAMADO")
-        Log.d(TAG, "════════════════════════════════════════")
-        Log.d(TAG, "⏰ Timestamp: ${System.currentTimeMillis()}")
-        Log.d(TAG, "📦 Intent recebido: $intent")
-
-        try {
-            val extras = intent?.extras
-            if (extras == null) {
-                Log.e(TAG, "❌ Intent extras é NULL - retornando null")
-                return null
-            }
-
-            Log.d(TAG, "📋 Extras disponíveis:")
-            for (key in extras.keySet()) {
-                Log.d(TAG, "   └─ $key = ${extras.get(key)}")
-            }
-
-            val eventName = extras.getString("eventName")
-            if (eventName == null) {
-                Log.e(TAG, "❌ eventName é NULL - retornando null")
-                return null
-            }
-
-            val regionId = extras.getString("regionId")
-            if (regionId == null) {
-                Log.e(TAG, "❌ regionId é NULL - retornando null")
-                return null
-            }
-
-            Log.d(TAG, "✅ Dados extraídos:")
-            Log.d(TAG, "   └─ eventName: $eventName")
-            Log.d(TAG, "   └─ regionId: $regionId")
-
-            val regionName = extras.getString("regionName") ?: ""
-            val regionData = extras.getString("regionData") ?: ""
-            val regionLatitude = extras.getDouble("regionLatitude", 0.0)
-            val regionLongitude = extras.getDouble("regionLongitude", 0.0)
-            val regionRadius = extras.getDouble("regionRadius", 100.0)
-
-            Log.d(TAG, "📍 Region data:")
-            Log.d(TAG, "   └─ name: $regionName")
-            Log.d(TAG, "   └─ data: $regionData")
-            Log.d(TAG, "   └─ latitude: $regionLatitude")
-            Log.d(TAG, "   └─ longitude: $regionLongitude")
-            Log.d(TAG, "   └─ radius: $regionRadius")
-
-            val regionMap = Arguments.createMap().apply {
-                putString("id", regionId)
-                putString("name", regionName)
-                putString("data", regionData)
-                putDouble("latitude", regionLatitude)
-                putDouble("longitude", regionLongitude)
-                putDouble("radius", regionRadius)
-            }
-
-            val timestamp = System.currentTimeMillis().toDouble()
-            val data = Arguments.createMap().apply {
-                putString("event", eventName)
-                putMap("region", regionMap)
-                putDouble("timestamp", timestamp)
-            }
-
-            Log.d(TAG, "📦 HeadlessTask data construído:")
-            Log.d(TAG, "   └─ event: $eventName")
-            Log.d(TAG, "   └─ timestamp: $timestamp")
-
-            val timeout = RegionManager.getHeadlessTimeout(applicationContext)
-            Log.d(TAG, "⏱️ Timeout configurado: ${timeout}ms")
-
-            Log.d(TAG, "🔧 Criando HeadlessJsTaskConfig:")
-            Log.d(TAG, "   └─ taskKey: ${GeofenceReceiver.HEADLESS_TASK_NAME}")
-            Log.d(TAG, "   └─ timeout: ${timeout}ms")
-            Log.d(TAG, "   └─ allowedInForeground: true")
-
-            val config = HeadlessJsTaskConfig(
-                GeofenceReceiver.HEADLESS_TASK_NAME,
-                data,
-                timeout.toLong(),
-                true
-            )
-
-            Log.d(TAG, "════════════════════════════════════════")
-            Log.d(TAG, "✅ HeadlessJsTaskConfig CRIADO COM SUCESSO!")
-            Log.d(TAG, "════════════════════════════════════════")
+    private fun buildNotification(intent: Intent?): Notification {
+        val event = intent?.getStringExtra(EXTRA_EVENT) ?: "geofence"
+        val smallIcon = applicationInfo.icon.takeIf { it != 0 } ?: android.R.drawable.ic_dialog_info
+        return Notification.Builder(this, CHANNEL_ID)
+            .setContentTitle("Geofence")
+            .setContentText("Evento: $event")
+            .setSmallIcon(smallIcon)
+            .setPriority(Notification.PRIORITY_LOW)
+            .build()
+    }
 
-            return config
-        } catch (e: Exception) {
-            Log.e(TAG, "════════════════════════════════════════")
-            Log.e(TAG, "💥 EXCEÇÃO em getTaskConfig():")
-            Log.e(TAG, "════════════════════════════════════════")
-            Log.e(TAG, "   └─ ${e.javaClass.simpleName}: ${e.message}")
-            Log.e(TAG, "   └─ StackTrace: ${e.stackTraceToString()}")
-            return null
-        }
+    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"
+        const val EXTRA_EVENT = "event"
+        const val EXTRA_TIMESTAMP = "timestamp"
     }
 }