@akbeniwal/react-native-smart-netinfo 1.0.4 → 1.0.6

package/ios/ReactNativeSmartNetinfo.mm

@@ -14,7 +14,7 @@ RCT_EXPORT_MODULE()
         _queue = dispatch_queue_create("com.smartnetinfo.networkmonitor", NULL);
         _monitor = nw_path_monitor_create();
         
-        __weak typeof(self) weakSelf = self;
+        __weak ReactNativeSmartNetinfo *weakSelf = self;
         nw_path_monitor_set_update_handler(_monitor, ^(nw_path_t path) {
             nw_path_status_t status = nw_path_get_status(path);
             BOOL isConnected = (status == nw_path_status_satisfied);
@@ -65,9 +65,4 @@ RCT_EXPORT_MODULE()
     return std::make_shared<facebook::react::NativeReactNativeSmartNetinfoSpecJSI>(params);
 }
 
-+ (NSString *)moduleName
-{
-  return @"ReactNativeSmartNetinfo";
-}
-
 @end

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@akbeniwal/react-native-smart-netinfo",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "A lightweight smart network monitoring library for React Native with internet reachability, latency monitoring, connection quality detection and speed testing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
+    "src",
     "dist",
     "android",
     "ios",

package/src/NativeReactNativeSmartNetinfo.ts

@@ -0,0 +1,8 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ReactNativeSmartNetinfo');

package/src/SmartNetInfo.ts

@@ -0,0 +1,342 @@
+import { AppState, AppStateStatus, NativeEventEmitter } from 'react-native';
+import NativeReactNativeSmartNetinfo from './NativeReactNativeSmartNetinfo';
+import { NetworkState, SmartNetInfoConfig, NetworkStateListener } from './types';
+import { getConnectionQuality } from './utils/getConnectionQuality';
+import { getLatency } from './utils/getLatency';
+import { runSpeedTest as executeSpeedTest } from './utils/runSpeedTest';
+
+const PING_URLS = [
+  'https://clients3.google.com/generate_204',
+  'https://www.apple.com/library/test/success.html',
+  'https://cloudflare-dns.com/dns-query',
+  'https://google.com/generate_204'
+];
+
+const SPEED_TEST_URL = 'https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js';
+
+class SmartNetInfoManager {
+  private pingUrlIndex = 0;
+  private config: Required<SmartNetInfoConfig> = {
+    pingIntervalMs: 30000,
+    timeoutMs: 5000,
+    speedTestFileSizeInBytes: 90000,
+    disableAutoSpeedTest: false,
+  };
+
+  private state: NetworkState = {
+    isConnected: null,
+    isInternetReachable: null,
+    latencyMs: null,
+    connectionQuality: null,
+    internetSpeed: null,
+    isTestingSpeed: false,
+  };
+
+  private listeners = new Set<NetworkStateListener>();
+  private timeoutId: ReturnType<typeof setTimeout> | null = null;
+  private appStateSubscription: { remove: () => void } | null = null;
+  private nativeEventEmitter: NativeEventEmitter | null = null;
+  private nativeEventSubscription: { remove: () => void } | null = null;
+  private isMonitoring = false;
+  private isChecking = false;
+
+  /**
+   * Configure the SmartNetInfo options.
+   * If already monitoring, it will restart the monitoring process to apply new intervals.
+   */
+  public configure(config: Partial<SmartNetInfoConfig>): void {
+    this.config = { ...this.config, ...config };
+    if (this.isMonitoring) {
+      this.stopMonitoring();
+      this.startMonitoring();
+    }
+  }
+
+  /**
+   * Fetches the current network state immediately by performing a connectivity check.
+   */
+  public async fetch(): Promise<NetworkState> {
+    await this.checkConnectivity();
+    return this.state;
+  }
+
+  /**
+   * Subscribe to network state changes.
+   * Automatically starts monitoring if it was not already running.
+   * 
+   * @param listener Callback function receiving the updated NetworkState
+   * @returns A cleanup function to unsubscribe
+   */
+  public addEventListener(listener: NetworkStateListener): () => void {
+    this.listeners.add(listener);
+    
+    // Provide the current state immediately to the new listener
+    listener(this.state);
+
+    if (!this.isMonitoring) {
+      this.startMonitoring();
+    }
+
+    return () => this.removeEventListener(listener);
+  }
+
+  /**
+   * Unsubscribe a listener from network state changes.
+   * Automatically stops monitoring if no listeners remain.
+   * 
+   * @param listener Callback function to unsubscribe
+   */
+  public removeEventListener(listener: NetworkStateListener): void {
+    this.listeners.delete(listener);
+    if (this.listeners.size === 0 && this.isMonitoring) {
+      this.stopMonitoring();
+    }
+  }
+
+  /**
+   * Triggers an internet speed test manually.
+   * 
+   * @returns Estimated download speed in Mbps, or null if test fails
+   */
+  public async runSpeedTest(): Promise<number | null> {
+    if (this.state.isTestingSpeed) {
+      return this.state.internetSpeed;
+    }
+
+    this.updateState({ isTestingSpeed: true });
+    
+    const timeout = Math.max(this.config.timeoutMs * 3, 15000);
+    const speed = await executeSpeedTest(SPEED_TEST_URL, this.config.speedTestFileSizeInBytes, timeout);
+    
+    this.updateState({
+      internetSpeed: speed,
+      isTestingSpeed: false,
+    });
+
+    return speed;
+  }
+
+  /**
+   * Start monitoring network status (polling, AppState transitions, and browser online/offline events).
+   */
+  public startMonitoring(): void {
+    if (this.isMonitoring) return;
+    this.isMonitoring = true;
+
+    // Set up Native Event Emitter if available
+    try {
+      if (NativeReactNativeSmartNetinfo) {
+        this.nativeEventEmitter = new NativeEventEmitter(NativeReactNativeSmartNetinfo as any);
+        this.nativeEventSubscription = this.nativeEventEmitter.addListener(
+          'NetworkStatusChanged',
+          this.handleNativeNetworkChange
+        );
+      }
+    } catch (e) {
+      console.warn('SmartNetInfo native module not found, falling back to pure polling');
+    }
+
+    // Run initial check immediately and then schedule subsequent checks
+    this.checkConnectivity().then(() => {
+      // Auto run speed test on initial connect if online
+      if (
+        this.state.isInternetReachable &&
+        this.state.internetSpeed === null &&
+        !this.config.disableAutoSpeedTest
+      ) {
+        this.runSpeedTest();
+      }
+      this.scheduleNextCheck();
+    });
+
+    // React Native AppState listener to detect foreground transitions
+    try {
+      this.appStateSubscription = AppState.addEventListener('change', this.handleAppStateChange);
+    } catch (error) {
+      console.warn('SmartNetInfo failed to register AppState listener:', error);
+    }
+
+    // Web browser window event listeners for react-native-web compatibility
+    const hasWindowListeners = typeof window !== 'undefined' && typeof window.addEventListener === 'function';
+    if (hasWindowListeners) {
+      window.addEventListener('online', this.handleWebOnline);
+      window.addEventListener('offline', this.handleWebOffline);
+    }
+  }
+
+  /**
+   * Stop monitoring network status and clean up timers and listeners.
+   */
+  public stopMonitoring(): void {
+    if (!this.isMonitoring) return;
+    this.isMonitoring = false;
+
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+
+    if (this.nativeEventSubscription) {
+      this.nativeEventSubscription.remove();
+      this.nativeEventSubscription = null;
+    }
+
+    if (this.appStateSubscription) {
+      if (typeof this.appStateSubscription.remove === 'function') {
+        this.appStateSubscription.remove();
+      } else {
+        // Fallback for older React Native versions
+        (AppState as any).removeEventListener?.('change', this.handleAppStateChange);
+      }
+      this.appStateSubscription = null;
+    }
+
+    const hasWindowListeners = typeof window !== 'undefined' && typeof window.removeEventListener === 'function';
+    if (hasWindowListeners) {
+      window.removeEventListener('online', this.handleWebOnline);
+      window.removeEventListener('offline', this.handleWebOffline);
+    }
+  }
+
+  private handleNativeNetworkChange = (event: { isConnected: boolean }) => {
+    if (!event.isConnected) {
+      this.updateState({
+        isConnected: false,
+        isInternetReachable: false,
+        latencyMs: null,
+        connectionQuality: null,
+      });
+      if (this.timeoutId) {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = null;
+      }
+    } else {
+      this.updateState({ isConnected: true });
+      this.checkConnectivity().finally(() => {
+        this.scheduleNextCheck();
+      });
+    }
+  };
+
+  private handleAppStateChange = (nextAppState: AppStateStatus): void => {
+    if (nextAppState === 'active') {
+      this.checkConnectivity().finally(() => {
+        this.scheduleNextCheck();
+      });
+    }
+  };
+
+  private handleWebOnline = (): void => {
+    this.updateState({ isConnected: true, isInternetReachable: true });
+    this.checkConnectivity().finally(() => {
+      this.scheduleNextCheck();
+    });
+  };
+
+  private handleWebOffline = (): void => {
+    this.updateState({
+      isConnected: false,
+      isInternetReachable: false,
+      latencyMs: null,
+      connectionQuality: null,
+    });
+  };
+
+  private scheduleNextCheck(): void {
+    if (!this.isMonitoring) return;
+
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+
+    if (this.config.pingIntervalMs <= 0) return;
+
+    // If native module explicitly told us we are offline (isConnected: false),
+    // we DO NOT poll at all to save battery. We wait for native event.
+    if (this.state.isConnected === false && this.nativeEventEmitter) {
+      return;
+    }
+
+    // When offline (without native fallback), check more frequently (every 3 seconds) to detect recovery quickly.
+    // When online, use the configured pingIntervalMs.
+    const isOffline = this.state.isInternetReachable === false;
+    const interval = isOffline
+      ? Math.min(this.config.pingIntervalMs, 3000)
+      : this.config.pingIntervalMs;
+
+    this.timeoutId = setTimeout(async () => {
+      await this.checkConnectivity();
+      this.scheduleNextCheck();
+    }, interval);
+  }
+
+  private async checkConnectivity(): Promise<void> {
+    if (this.isChecking) return;
+    this.isChecking = true;
+
+    try {
+      // Add a buffer to timeout when we are currently offline to allow the radio to wake up
+      const isCurrentlyOffline = this.state.isInternetReachable === false;
+      const actualTimeout = isCurrentlyOffline
+        ? Math.max(this.config.timeoutMs, 4000)
+        : this.config.timeoutMs;
+
+      const currentPingUrl = PING_URLS[this.pingUrlIndex];
+      // Cycle to the next URL for the next check to avoid DNS caching issues if it fails
+      this.pingUrlIndex = (this.pingUrlIndex + 1) % PING_URLS.length;
+
+      const { isReachable, latencyMs } = await getLatency(currentPingUrl, actualTimeout);
+      
+      const wasInternetReachable = this.state.isInternetReachable;
+
+      this.updateState({
+        isConnected: isReachable,
+        isInternetReachable: isReachable,
+        latencyMs,
+        connectionQuality: getConnectionQuality(latencyMs),
+      });
+
+      // If internet just became reachable and we haven't run speed test yet, trigger auto speed test
+      if (
+        isReachable &&
+        wasInternetReachable === false &&
+        this.state.internetSpeed === null &&
+        !this.config.disableAutoSpeedTest
+      ) {
+        this.runSpeedTest();
+      }
+    } catch (error) {
+      console.warn('SmartNetInfo failed during checkConnectivity:', error);
+    } finally {
+      this.isChecking = false;
+    }
+  }
+
+  private updateState(partialState: Partial<NetworkState>): void {
+    const nextState = { ...this.state, ...partialState };
+    
+    // Check if anything actually changed
+    const hasChanged = Object.keys(nextState).some(
+      (key) => (nextState as any)[key] !== (this.state as any)[key]
+    );
+
+    if (hasChanged) {
+      this.state = nextState;
+      this.notifyListeners();
+    }
+  }
+
+  private notifyListeners(): void {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(this.state);
+      } catch (error) {
+        console.error('Error in SmartNetInfo listener:', error);
+      }
+    });
+  }
+}
+
+export const SmartNetInfo = new SmartNetInfoManager();
+export default SmartNetInfo;

package/src/index.ts

@@ -0,0 +1,2 @@
+export { SmartNetInfo, default } from './SmartNetInfo';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,29 @@
+export type ConnectionQuality = 'poor' | 'good' | 'excellent';
+
+export interface NetworkState {
+  /** True if the network check succeeded, false if it failed or timed out */
+  isConnected: boolean | null;
+  /** True if internet reachability check succeeded */
+  isInternetReachable: boolean | null;
+  /** Round-trip ping latency in milliseconds */
+  latencyMs: number | null;
+  /** Connection quality based on latency ('poor' | 'good' | 'excellent') */
+  connectionQuality: ConnectionQuality | null;
+  /** Estimated internet download speed in Mbps (automatically measured when online) */
+  internetSpeed: number | null;
+  /** True if a speed test is currently running */
+  isTestingSpeed: boolean;
+}
+
+export interface SmartNetInfoConfig {
+  /** The interval in milliseconds to poll the connection (defaults to 30000ms, set to 0 to disable polling) */
+  pingIntervalMs?: number;
+  /** The fetch timeout in milliseconds (defaults to 5000ms) */
+  timeoutMs?: number;
+  /** File size of the speed test URL in bytes (defaults to 90000 bytes for jQuery) */
+  speedTestFileSizeInBytes?: number;
+  /** If true, disables the automatic speed test on mount/online transitions (defaults to false) */
+  disableAutoSpeedTest?: boolean;
+}
+
+export type NetworkStateListener = (state: NetworkState) => void;

package/src/utils/getConnectionQuality.ts

@@ -0,0 +1,20 @@
+import { ConnectionQuality } from '../types';
+
+/**
+ * Categorizes a round-trip connection latency (in milliseconds) into a descriptive rating.
+ * 
+ * @param latencyMs Latency in milliseconds or null if offline/unknown
+ * @returns ConnectionQuality rating or null
+ */
+export function getConnectionQuality(latencyMs: number | null): ConnectionQuality | null {
+  if (latencyMs === null || latencyMs < 0) {
+    return null;
+  }
+  if (latencyMs < 150) {
+    return 'excellent';
+  }
+  if (latencyMs < 400) {
+    return 'good';
+  }
+  return 'poor';
+}

package/src/utils/getLatency.ts

@@ -0,0 +1,61 @@
+export interface LatencyResult {
+  /** True if the ping request responded with an HTTP status < 400 */
+  isReachable: boolean;
+  /** Latency in milliseconds, or null if the check timed out or failed */
+  latencyMs: number | null;
+}
+
+/**
+ * Pings a URL to verify internet reachability and measure round-trip latency.
+ * Uses an AbortController to support timeouts.
+ * 
+ * @param pingUrl The target URL to ping
+ * @param timeoutMs Request timeout in milliseconds
+ * @returns A promise resolving to LatencyResult
+ */
+export async function getLatency(pingUrl: string, timeoutMs: number): Promise<LatencyResult> {
+  const startTime = Date.now();
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+  try {
+    const controller = new AbortController();
+    timeoutId = setTimeout(() => {
+      controller.abort();
+    }, timeoutMs);
+
+    // Append dynamic timestamp and random string to strictly bypass network/DNS caching
+    const uniqueUrl = `${pingUrl}${pingUrl.includes('?') ? '&' : '?'}t=${Date.now()}&r=${Math.random().toString().slice(2)}`;
+
+    // Perform GET request to verify connectivity.
+    // We use GET instead of HEAD for maximum compatibility across various CDNs and proxies.
+    // Since clients3.google.com/generate_204 returns a 204 No Content response,
+    // using GET has negligible bandwidth usage.
+    const response = await fetch(uniqueUrl, {
+      method: 'GET',
+      signal: controller.signal,
+      headers: {
+        'Cache-Control': 'no-cache, no-store, must-revalidate',
+        'Pragma': 'no-cache',
+        'Expires': '0',
+      },
+    });
+
+    // Fully consume the response body to prevent connection leaks in React Native
+    try {
+      await response.text();
+    } catch (e) {
+      // ignore
+    }
+
+    const isReachable = response.ok || response.status < 400;
+    const latencyMs = Date.now() - startTime;
+    return { isReachable, latencyMs };
+  } catch (error) {
+    console.warn(`[SmartNetInfo] getLatency failed:`, error instanceof Error ? error.message : error);
+    // If it fails due to network/timeout, we are offline.
+    return { isReachable: false, latencyMs: null };
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}

package/src/utils/runSpeedTest.ts

@@ -0,0 +1,60 @@
+/**
+ * Runs a download speed test by fetching a remote asset, reading the response
+ * completely, and calculating the throughput speed in Mbps.
+ * 
+ * @param speedTestUrl URL of the remote asset to download
+ * @param speedTestFileSizeInBytes Known size of the remote asset in bytes
+ * @returns A promise resolving to the estimated download speed in Mbps, or null if the test fails
+ */
+export async function runSpeedTest(
+  speedTestUrl: string,
+  speedTestFileSizeInBytes: number,
+  timeoutMs: number = 15000
+): Promise<number | null> {
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+  try {
+    const startTime = Date.now();
+    const controller = new AbortController();
+    
+    timeoutId = setTimeout(() => {
+      controller.abort();
+    }, timeoutMs);
+    
+    const uniqueUrl = `${speedTestUrl}${speedTestUrl.includes('?') ? '&' : '?'}t=${Date.now()}&r=${Math.random().toString().slice(2)}`;
+    
+    const response = await fetch(uniqueUrl, {
+      method: 'GET',
+      signal: controller.signal,
+      headers: {
+        'Cache-Control': 'no-cache, no-store, must-revalidate',
+        'Pragma': 'no-cache',
+        'Expires': '0',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Speed test download failed with status: ${response.status}`);
+    }
+
+    // Fully consume the response body so that we measure the complete download duration
+    await response.text();
+
+    const durationSec = (Date.now() - startTime) / 1000;
+    if (durationSec <= 0) {
+      return null;
+    }
+
+    const fileSizeBits = speedTestFileSizeInBytes * 8;
+    const speedMbps = fileSizeBits / durationSec / 1000000;
+
+    // Round to 2 decimal places (e.g. 15.45)
+    return Math.round(speedMbps * 100) / 100;
+  } catch (error) {
+    console.warn('Network speed test failed:', error);
+    return null;
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}