Added android "getCurrentGeofences" bridge function, tagged it internal

also added tests

Author: Evan Masseau

android/src/main/java/com/klaviyoreactnativesdk/KlaviyoReactNativeSdkModule.kt

@@ -1,5 +1,6 @@
 package com.klaviyoreactnativesdk
 
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -20,6 +21,7 @@ import com.klaviyo.core.utils.AdvancedAPI
 import com.klaviyo.forms.InAppFormsConfig
 import com.klaviyo.forms.registerForInAppForms
 import com.klaviyo.forms.unregisterFromInAppForms
+import com.klaviyo.location.LocationManager
 import com.klaviyo.location.registerGeofencing
 import com.klaviyo.location.unregisterGeofencing
 import java.io.Serializable
@@ -99,6 +101,31 @@ class KlaviyoReactNativeSdkModule(
     Klaviyo.unregisterGeofencing()
   }
 
+  @ReactMethod
+  fun getCurrentGeofences(callback: Callback) {
+    // Note: in the future, we may be storing more fences than we are observing, so we'd have to update this
+    val geofencesArray = Arguments.createArray()
+    Registry.getOrNull<LocationManager>()?.getStoredGeofences()?.forEach { geofence ->
+      geofencesArray.pushMap(
+        Arguments.createMap().apply {
+          putString("identifier", geofence.id)
+          putDouble("latitude", geofence.latitude)
+          putDouble("longitude", geofence.longitude)
+          putDouble("radius", geofence.radius.toDouble())
+        },
+      )
+    } ?: run {
+      Registry.log.wtf("Geofencing is not yet registered")
+    }
+
+    val resultMap =
+      Arguments.createMap().apply {
+        putArray("geofences", geofencesArray)
+      }
+
+    callback.invoke(resultMap)
+  }
+
   @ReactMethod
   fun setProfile(profile: ReadableMap) {
     val parsedProfile = Profile()

example/src/KlaviyoReactWrapper.ts

@@ -141,6 +141,7 @@ export const unregisterGeofencing = async () => {
 
 export const getCurrentGeofences = async () => {
   try {
+    // Note: this @internal method is intended only for demonstration and debugging purposes
     Klaviyo.getCurrentGeofences((result) => {
       const { geofences } = result;
       console.log('Current geofences:', JSON.stringify(geofences, null, 2));

src/Geofencing.ts

@@ -5,9 +5,31 @@ export interface Geofence {
   radius: number;
 }
 
+/**
+ * Interface for the Klaviyo location module
+ */
 export interface KlaviyoGeofencingApi {
+  /**
+   * Begin geofence monitoring
+   * Once proper permissions are granted from the user, we will fetch
+   * geofences configured for your account and begin reporting
+   * geofence transitions as analytics events.
+   */
   registerGeofencing(): void;
+
+  /**
+   * Stop monitoring geofences
+   */
   unregisterGeofencing(): void;
+
+  /**
+   * Gets the currently monitored geofences from the native SDK.
+   *
+   * This is intended for demonstration and debugging purposes only.
+   * It may be subject to change or removal without notice.
+   *
+   * @internal
+   */
   getCurrentGeofences(
     callback: (result: { geofences: Geofence[] }) => void
   ): void;

src/__tests__/index.test.tsx

@@ -24,6 +24,9 @@ jest.mock('react-native', () => {
         createEvent: jest.fn(),
         registerForInAppForms: jest.fn(),
         unregisterFromInAppForms: jest.fn(),
+        registerGeofencing: jest.fn(),
+        unregisterGeofencing: jest.fn(),
+        getCurrentGeofences: jest.fn(),
         handleUniversalTrackingLink: jest.fn(),
         getConstants: jest.fn().mockReturnValue({
           PROFILE_KEYS: {
@@ -265,6 +268,56 @@ describe('Klaviyo SDK', () => {
     });
   });
 
+  describe('geofencing', () => {
+    it('should register for geofencing', () => {
+      Klaviyo.registerGeofencing();
+      expect(
+        NativeModules.KlaviyoReactNativeSdk.registerGeofencing
+      ).toHaveBeenCalledTimes(1);
+    });
+
+    it('should unregister from geofencing', () => {
+      Klaviyo.unregisterGeofencing();
+      expect(
+        NativeModules.KlaviyoReactNativeSdk.unregisterGeofencing
+      ).toHaveBeenCalledTimes(1);
+    });
+
+    it('should get current geofences through callback correctly', () => {
+      const mockGeofences = {
+        geofences: [
+          {
+            identifier: 'geofence_1',
+            latitude: 42.3601,
+            longitude: -71.0589,
+            radius: 100,
+          },
+          {
+            identifier: 'geofence_2',
+            latitude: 40.7128,
+            longitude: -74.006,
+            radius: 200,
+          },
+        ],
+      };
+
+      // Test with callback
+      Klaviyo.getCurrentGeofences((result) => {
+        expect(result).toEqual(mockGeofences);
+      });
+
+      // Simulate callback invocation
+      const getCurrentGeofencesCall =
+        NativeModules.KlaviyoReactNativeSdk.getCurrentGeofences.mock
+          .calls[0][0];
+      getCurrentGeofencesCall(mockGeofences);
+
+      expect(
+        NativeModules.KlaviyoReactNativeSdk.getCurrentGeofences
+      ).toHaveBeenCalled();
+    });
+  });
+
   describe('tracking links', () => {
     it('should call the native handleUniversalTrackingLink method with a valid Klaviyo universal tracking link', () => {
       const trackingLink = 'https://klaviyo.com/u/abc123';