feat: network-awarness [rn]

android/src/main/AndroidManifest.xml

@@ -1,3 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.metarouter.reactnative">
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 </manifest>

android/src/main/java/com/metarouter/reactnative/MetaRouterNetworkMonitorModule.kt

@@ -0,0 +1,119 @@
+package com.metarouter.reactnative
+
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.content.Context
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class MetaRouterNetworkMonitorModule(
+    private val reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "MetaRouterNetworkMonitor"
+
+    @Volatile
+    private var isConnected: Boolean = true
+
+    private var connectivityManager: ConnectivityManager? = null
+    private var networkCallback: ConnectivityManager.NetworkCallback? = null
+
+    init {
+        connectivityManager = try {
+            reactContext.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+        } catch (_: Exception) {
+            null
+        }
+
+        // Snapshot initial state
+        connectivityManager?.let { cm ->
+            isConnected = try {
+                val network = cm.activeNetwork
+                val caps = network?.let { cm.getNetworkCapabilities(it) }
+                caps?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true
+            } catch (_: Exception) {
+                true // fallback
+            }
+        }
+
+        // Register callback for changes
+        connectivityManager?.let { cm ->
+            val request = NetworkRequest.Builder()
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                .build()
+
+            val cb = object : ConnectivityManager.NetworkCallback() {
+                override fun onAvailable(network: Network) {
+                    if (!isConnected) {
+                        isConnected = true
+                        sendEvent(true)
+                    }
+                }
+
+                override fun onLost(network: Network) {
+                    val activeNet = cm.activeNetwork
+                    val caps = activeNet?.let { cm.getNetworkCapabilities(it) }
+                    val hasInternet = caps?.hasCapability(
+                        NetworkCapabilities.NET_CAPABILITY_INTERNET
+                    ) == true
+                    if (!hasInternet && isConnected) {
+                        isConnected = false
+                        sendEvent(false)
+                    }
+                }
+            }
+
+            try {
+                cm.registerNetworkCallback(request, cb)
+                networkCallback = cb
+            } catch (_: SecurityException) {
+                // Missing ACCESS_NETWORK_STATE — fallback to always connected
+            }
+        }
+    }
+
+    private fun sendEvent(connected: Boolean) {
+        val params = Arguments.createMap().apply {
+            putBoolean("isConnected", connected)
+        }
+        try {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("onConnectivityChange", params)
+        } catch (_: Exception) {
+            // JS runtime not ready yet — ignore
+        }
+    }
+
+    @ReactMethod
+    fun getCurrentStatus(promise: Promise) {
+        promise.resolve(isConnected)
+    }
+
+    @ReactMethod
+    fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) {
+        // Required for RN event emitter
+    }
+
+    @ReactMethod
+    fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Int) {
+        // Required for RN event emitter
+    }
+
+    override fun invalidate() {
+        networkCallback?.let { cb ->
+            try {
+                connectivityManager?.unregisterNetworkCallback(cb)
+            } catch (_: Exception) {
+                // ignore
+            }
+        }
+        networkCallback = null
+    }
+}

android/src/main/java/com/metarouter/reactnative/MetaRouterQueueStoragePackage.kt → android/src/main/java/com/metarouter/reactnative/MetaRouterPackage.kt

@@ -5,11 +5,14 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
-class MetaRouterQueueStoragePackage : ReactPackage {
+class MetaRouterPackage : ReactPackage {
     override fun createNativeModules(
         reactContext: ReactApplicationContext
     ): List<NativeModule> {
-        return listOf(MetaRouterQueueStorageModule(reactContext))
+        return listOf(
+            MetaRouterQueueStorageModule(reactContext),
+            MetaRouterNetworkMonitorModule(reactContext)
+        )
     }
 
     override fun createViewManagers(

ios/MetaRouterNetworkMonitor.m

@@ -0,0 +1,76 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <Network/Network.h>
+
+@interface MetaRouterNetworkMonitor : RCTEventEmitter <RCTBridgeModule>
+@end
+
+@implementation MetaRouterNetworkMonitor {
+  nw_path_monitor_t _monitor;
+  dispatch_queue_t _monitorQueue;
+  BOOL _isConnected;
+  BOOL _hasListeners;
+}
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _isConnected = YES; // optimistic default
+    _hasListeners = NO;
+    _monitorQueue = dispatch_queue_create("com.metarouter.network.monitor", DISPATCH_QUEUE_SERIAL);
+    _monitor = nw_path_monitor_create();
+
+    __weak typeof(self) weakSelf = self;
+    nw_path_monitor_set_update_handler(_monitor, ^(nw_path_t path) {
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      if (!strongSelf) return;
+
+      BOOL connected = (nw_path_get_status(path) == nw_path_status_satisfied);
+      BOOL changed = (connected != strongSelf->_isConnected);
+      strongSelf->_isConnected = connected;
+
+      if (changed && strongSelf->_hasListeners) {
+        [strongSelf sendEventWithName:@"onConnectivityChange"
+                                 body:@{@"isConnected": @(connected)}];
+      }
+    });
+
+    nw_path_monitor_set_queue(_monitor, _monitorQueue);
+    nw_path_monitor_start(_monitor);
+  }
+  return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[@"onConnectivityChange"];
+}
+
+- (void)startObserving {
+  _hasListeners = YES;
+}
+
+- (void)stopObserving {
+  _hasListeners = NO;
+}
+
+RCT_EXPORT_METHOD(getCurrentStatus:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(_monitorQueue, ^{
+    resolve(@(self->_isConnected));
+  });
+}
+
+- (void)dealloc {
+  if (_monitor) {
+    nw_path_monitor_cancel(_monitor);
+  }
+}
+
+@end

react-native.config.js

@@ -7,8 +7,8 @@ module.exports = {
       android: {
         sourceDir: './android',
         packageImportPath:
-          'import com.metarouter.reactnative.MetaRouterQueueStoragePackage;',
-        packageInstance: 'new MetaRouterQueueStoragePackage()',
+          'import com.metarouter.reactnative.MetaRouterPackage;',
+        packageInstance: 'new MetaRouterPackage()',
       },
     },
   },

src/analytics/MetaRouterAnalyticsClient.test.ts

@@ -1,6 +1,7 @@
 import { MetaRouterAnalyticsClient } from './MetaRouterAnalyticsClient';
 import type { InitOptions } from './types';
 import { AppState } from 'react-native';
+import { StubNetworkMonitor } from './utils/networkMonitor';
 
 const mockAddEventListener = jest.fn();
 jest
@@ -594,6 +595,87 @@ describe('MetaRouterAnalyticsClient', () => {
     expect(client.queue[0].context.device.advertisingId).toBeUndefined();
   });
 
+  describe('network awareness', () => {
+    it('getDebugInfo includes networkStatus', async () => {
+      const monitor = new StubNetworkMonitor('connected');
+      const client = new MetaRouterAnalyticsClient(opts, {
+        networkMonitor: monitor,
+      });
+      await client.init();
+
+      const debugInfo = await client.getDebugInfo();
+      expect(debugInfo.networkStatus).toBe('connected');
+    });
+
+    it('getDebugInfo reflects disconnected status', async () => {
+      const monitor = new StubNetworkMonitor('disconnected');
+      const client = new MetaRouterAnalyticsClient(opts, {
+        networkMonitor: monitor,
+      });
+      await client.init();
+
+      const debugInfo = await client.getDebugInfo();
+      expect(debugInfo.networkStatus).toBe('disconnected');
+    });
+
+    it('SDK functions normally when network monitoring unavailable', async () => {
+      // Don't inject networkMonitor — constructor will try to create
+      // a real NetworkMonitor which will fail in test env and fallback
+      // to always-connected
+      const client = new MetaRouterAnalyticsClient(opts);
+      await client.init();
+
+      client.track('Test Event');
+      expect(client.queue).toHaveLength(1);
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await client.flush();
+      expect(fetch).toHaveBeenCalled();
+    });
+
+    it('offline -> online transition resets circuit breaker and triggers flush', async () => {
+      const monitor = new StubNetworkMonitor('connected');
+      const client = new MetaRouterAnalyticsClient(opts, {
+        networkMonitor: monitor,
+      });
+      await client.init();
+
+      // Go offline
+      monitor.simulate('disconnected');
+
+      // Track events while offline
+      client.track('Offline Event 1');
+      client.track('Offline Event 2');
+
+      // Flush should not send (offline)
+      await client.flush();
+      // Events should still be in queue since network is unavailable
+      // (the dispatcher guard prevents HTTP calls)
+
+      // Go online — should trigger flush
+      (global as any).fetch = jest
+        .fn()
+        .mockResolvedValue({ ok: true, status: 200 });
+      monitor.simulate('connected');
+
+      // Allow the async flush to complete
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(fetch).toHaveBeenCalled();
+    });
+
+    it('reset() cleans up network monitor', async () => {
+      const monitor = new StubNetworkMonitor('connected');
+      const stopSpy = jest.spyOn(monitor, 'stop');
+      const client = new MetaRouterAnalyticsClient(opts, {
+        networkMonitor: monitor,
+      });
+      await client.init();
+
+      await client.reset();
+      expect(stopSpy).toHaveBeenCalled();
+    });
+  });
+
   describe('tracing', () => {
     it('does not include Trace header by default', async () => {
       const client = new MetaRouterAnalyticsClient(opts);