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

package/README.md

@@ -1,173 +1,161 @@
-# 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)
+# 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,
+    // opcional: string livre (ex. JSON) — volta em GeofenceEvent.data
+    data: JSON.stringify({ lojaId: '123', promo: true }),
+  },
+]);
+// 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                     |
+| `data`        | `string` | Não         | Payload opaco; repassado no evento para você dar `JSON.parse` etc. |
+
+---
+
+## Evento (`GeofenceEvent`)
+
+- `geofenceId` — ID da geofence  
+- `event` — `'enter' | 'exit' | 'dwell'`  
+- `timestamp`, `name`, `latitude`, `longitude`, `radius` — quando disponíveis  
+- `data` — mesma string definida em `GeofenceModel.data` (vazio se não houver)  
+
+---
+
+## 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.
+
+---
+
+## 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/java/com/geofencemanager/GeofenceBroadcastReceiver.kt

@@ -1,133 +1,91 @@
-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 com.geofencemanager
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.gms.location.Geofence
+import com.google.android.gms.location.GeofencingEvent
+
+class GeofenceBroadcastReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context?, intent: Intent?) {
+        if (context == null || intent == null) return
+        if (intent.action != GeofenceManagerModule.GEOFENCE_ACTION) return
+
+        val geofencingEvent = GeofencingEvent.fromIntent(intent) ?: return
+        if (geofencingEvent.hasError()) return
+
+        if (GeofenceManagerModule.isWithinGracePeriod(context)) 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
+        }
+
+        val triggeringGeofences = geofencingEvent.triggeringGeofences ?: return
+        if (triggeringGeofences.isEmpty()) return
+
+        val reactContext = GeofenceManagerModule.reactContextRef
+        val timestamp = System.currentTimeMillis().toDouble()
+        val isForeground = reactContext != null && reactContext.hasActiveReactInstance()
+
+        if (isForeground) {
+            val ctx = reactContext!!
+            val geofenceIds = triggeringGeofences.map { it.requestId }
+            val eventNameForRunnable = eventName
+            Handler(Looper.getMainLooper()).postDelayed({
+                if (!ctx.hasActiveReactInstance()) return@postDelayed
+                try {
+                    val emitter = ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    for (geofenceId in geofenceIds) {
+                        val details = GeofenceManagerModule.getGeofenceDetails(context, geofenceId)
+                        val params = GeofenceManagerModule.buildEventParams(
+                            geofenceId,
+                            eventNameForRunnable,
+                            timestamp,
+                            details
+                        ) ?: continue
+                        emitter.emit("onGeofenceTransition", params)
+                    }
+                } catch (_: Exception) { }
+            }, 50)
+            return
+        }
+
+        val appContext = context.applicationContext
+        HeadlessJsTaskService.acquireWakeLockNow(appContext)
+        for (geofence in triggeringGeofences) {
+            val details = GeofenceManagerModule.getGeofenceDetails(context, geofence.requestId)
+            if (GeofenceManagerModule.buildEventParams(
+                    geofence.requestId,
+                    eventName,
+                    timestamp,
+                    details
+                ) == null
+            ) {
+                continue
+            }
+            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)
+                } else {
+                    appContext.startService(serviceIntent)
+                }
+            } catch (_: Exception) { }
+        }
+    }
+}