@ohos-ports/expo-network 57.0.2-beta.0

package/android/src/main/java/expo/modules/network/NetworkModule.kt

@@ -0,0 +1,281 @@
+package expo.modules.network
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkInfo
+import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+import android.util.Log
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.math.BigInteger
+import java.net.InetAddress
+import java.net.UnknownHostException
+import java.nio.ByteOrder
+
+private val TAG = NetworkModule::class.java.simpleName
+
+internal const val NETWORK_STATE_EVENT_NAME = "onNetworkStateChanged"
+
+class NetworkModule : Module() {
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+  private val connectivityManager: ConnectivityManager
+    get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+  private val mainHandler = Handler(Looper.getMainLooper())
+  private val DELAY_MS = 250
+  private var isNetworkCallbackRegistered = false
+
+  private val emitRunnable = Runnable { emitNetworkState() }
+
+  private val networkCallback = object : ConnectivityManager.NetworkCallback() {
+    override fun onAvailable(network: android.net.Network) {
+      asyncEmitNetworkState(DELAY_MS)
+    }
+
+    override fun onLost(lostNetwork: android.net.Network) {
+      // We intentionally do NOT reuse asyncEmitNetworkState(DELAY_MS) here.
+      //
+      // The 250ms delay used by onAvailable cannot be applied to onLost. On
+      // Android 13+, connectivityManager.activeNetwork continues to return the
+      // just-lost Network object even after the delay. Re-querying it would
+      // emit a stale "isConnected = true" event — the exact bug reported in
+      // https://github.com/expo/expo/issues/37972. This behavior isn't
+      // documented by AOSP as version-specific, so we apply this check
+      // defensively on all API 29+ devices.
+      //
+      // Instead, we compare the lost network against the current active network.
+      // If they match (or activeNetwork is null), there is no replacement
+      // network and we emit a disconnected state directly. If a different
+      // network is active (e.g. cellular), we emit
+      // its state instead.
+      //
+      // Note: android.net.Network.equals() compares by netId, so the check
+      // below is a reliable "same network" comparison.
+      //
+      // We still post to the main looper because sendEvent must run on the
+      // main thread; we just skip the artificial delay.
+      mainHandler.removeCallbacks(emitRunnable)
+      mainHandler.post {
+        try {
+          val activeNetwork = connectivityManager.activeNetwork
+          if (activeNetwork == null || activeNetwork == lostNetwork) {
+            val result = Bundle().apply {
+              putString("type", NetworkStateType.NONE.value)
+              putBoolean("isInternetReachable", false)
+              putBoolean("isConnected", false)
+            }
+            sendEvent(NETWORK_STATE_EVENT_NAME, result)
+          } else {
+            emitNetworkState()
+          }
+        } catch (e: SecurityException) {
+          // Missing ACCESS_NETWORK_STATE permission (or runtime revocation).
+          // Ensure the permission is declared in AndroidManifest.xml and
+          // granted at runtime on devices that require it.
+          Log.w(TAG, "expo-network could not read network state in onLost: missing ACCESS_NETWORK_STATE permission", e)
+        } catch (e: Exception) {
+          // The runnable may outlive the module if the React context is torn
+          // down between the ConnectivityManager.NetworkCallback firing and
+          // the posted runnable executing. In that case, the `connectivityManager`
+          // getter throws `ReactContextLost` when it
+          // attempts to resolve `appContext.reactContext`. Since
+          // unregisterNetworkCallback only prevents future callbacks and
+          // cannot cancel a runnable that is already in the queue, we must
+          // catch teardown-time exceptions here to avoid crashing the
+          // host app's main thread.
+          Log.w(TAG, "expo-network dropped a network state update during teardown (the module or React context is no longer available)", e)
+        }
+      }
+    }
+
+    override fun onCapabilitiesChanged(network: android.net.Network, networkCapabilities: NetworkCapabilities) {
+      asyncEmitNetworkState(DELAY_MS)
+    }
+  }
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNetwork")
+
+    Events(NETWORK_STATE_EVENT_NAME)
+
+    OnCreate {
+      try {
+        connectivityManager.registerDefaultNetworkCallback(networkCallback)
+        isNetworkCallbackRegistered = true
+      } catch (e: SecurityException) {
+        Log.w(TAG, "expo-network cannot observe internet reachability: missing ACCESS_NETWORK_STATE permission", e)
+      } catch (e: RuntimeException) {
+        Log.e(TAG, "expo-network cannot observe internet reachability, too many callbacks registered!", e)
+      }
+    }
+
+    OnDestroy {
+      mainHandler.removeCallbacks(emitRunnable)
+      if (isNetworkCallbackRegistered) {
+        try {
+          connectivityManager.unregisterNetworkCallback(networkCallback)
+        } catch (e: SecurityException) {
+          Log.w(TAG, "expo-network could not unregister network callback: missing ACCESS_NETWORK_STATE permission", e)
+        } catch (e: Exception) {
+          Log.w(TAG, "expo-network could not unregister network callback during teardown", e)
+        } finally {
+          isNetworkCallbackRegistered = false
+        }
+      }
+    }
+
+    AsyncFunction("getNetworkStateAsync") {
+      return@AsyncFunction fetchNetworkState()
+    }
+
+    AsyncFunction<String>("getIpAddressAsync") {
+      return@AsyncFunction rawIpToString(wifiInfo.ipAddress)
+    }
+
+    AsyncFunction<Boolean>("isAirplaneModeEnabledAsync") {
+      return@AsyncFunction Settings.Global.getInt(context.contentResolver, Settings.Global.AIRPLANE_MODE_ON, 0) != 0
+    }
+  }
+
+  enum class NetworkStateType(val value: String) {
+    NONE("NONE"),
+    UNKNOWN("UNKNOWN"),
+    CELLULAR("CELLULAR"),
+    WIFI("WIFI"),
+    BLUETOOTH("BLUETOOTH"),
+    ETHERNET("ETHERNET"),
+    WIMAX("WIMAX"),
+    VPN("VPN"),
+    OTHER("OTHER");
+
+    val isDefined: Boolean
+      get() = this.value != "NONE" && this.value != "UNKNOWN"
+  }
+
+  private fun emitNetworkState() {
+    try {
+      val networkState = fetchNetworkState()
+      sendEvent(NETWORK_STATE_EVENT_NAME, networkState)
+    } catch (e: SecurityException) {
+      Log.w(TAG, "expo-network could not read network state: missing ACCESS_NETWORK_STATE permission", e)
+    } catch (e: Exception) {
+      // The runnable may outlive the module if the React context is torn down between the
+      // ConnectivityManager callback firing and this runnable executing.
+      Log.w(TAG, "expo-network dropped a delayed network state update during teardown (the module or React context is no longer available)", e)
+    }
+  }
+
+  /**
+   * Emits the network state with a delay to prevent a race condition.
+   * This delay ensures we read the actual current network state rather than stale information.
+   * Debounced: rapid successive calls collapse into a single emission.
+   */
+  private fun asyncEmitNetworkState(delay: Int) {
+    mainHandler.removeCallbacks(emitRunnable)
+    mainHandler.postDelayed(emitRunnable, delay.toLong())
+  }
+
+  private fun fetchNetworkState(): Bundle {
+    val result = Bundle()
+
+    try {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) { // use getActiveNetworkInfo before api level 29
+        val netInfo = connectivityManager.activeNetworkInfo
+        val connectionType = getConnectionType(netInfo)
+        val isInternetReachable = isInternetReachable(connectivityManager)
+
+        result.apply {
+          putBoolean("isInternetReachable", isInternetReachable)
+          putString("type", connectionType.value)
+          putBoolean("isConnected", connectionType.isDefined)
+        }
+
+        return result
+      } else {
+        val network = connectivityManager.activeNetwork
+        val isInternetReachable = isInternetReachable(connectivityManager)
+
+        val connectionType = if (network != null) {
+          val netCapabilities = connectivityManager.getNetworkCapabilities(network)
+          getConnectionType(netCapabilities)
+        } else {
+          null
+        }
+
+        result.apply {
+          putString("type", connectionType?.value ?: NetworkStateType.NONE.value)
+          putBoolean("isInternetReachable", isInternetReachable)
+          putBoolean("isConnected", connectionType != null && connectionType.isDefined)
+        }
+        return result
+      }
+    } catch (e: Exception) {
+      result.apply {
+        putString("type", NetworkStateType.UNKNOWN.value)
+        putBoolean("isInternetReachable", false)
+        putBoolean("isConnected", false)
+      }
+      return result
+    }
+  }
+
+  private val wifiInfo: WifiInfo
+    get() = try {
+      val manager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
+      manager.connectionInfo
+    } catch (e: Exception) {
+      Log.e(TAG, e.message ?: "expo-network could not acquire Wi-Fi information")
+      throw NetworkWifiException(e)
+    }
+
+  private fun getConnectionType(netInfo: NetworkInfo?): NetworkStateType = when (netInfo?.type) {
+    ConnectivityManager.TYPE_MOBILE,
+    ConnectivityManager.TYPE_MOBILE_DUN -> NetworkStateType.CELLULAR
+    ConnectivityManager.TYPE_WIFI -> NetworkStateType.WIFI
+    ConnectivityManager.TYPE_BLUETOOTH -> NetworkStateType.BLUETOOTH
+    ConnectivityManager.TYPE_ETHERNET -> NetworkStateType.ETHERNET
+    ConnectivityManager.TYPE_WIMAX -> NetworkStateType.WIMAX
+    ConnectivityManager.TYPE_VPN -> NetworkStateType.VPN
+    else -> NetworkStateType.UNKNOWN
+  }
+
+  private fun getConnectionType(netCapabilities: NetworkCapabilities?): NetworkStateType =
+    when {
+      netCapabilities == null -> NetworkStateType.UNKNOWN
+      netCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> NetworkStateType.CELLULAR
+      netCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) || netCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI_AWARE) -> NetworkStateType.WIFI
+      netCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH) -> NetworkStateType.BLUETOOTH
+      netCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> NetworkStateType.ETHERNET
+      netCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN) -> NetworkStateType.VPN
+      else -> NetworkStateType.UNKNOWN
+    }
+
+  private fun rawIpToString(ipAddress: Int): String {
+    // Convert little-endian to big-endian if needed
+    val ip = if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+      Integer.reverseBytes(ipAddress)
+    } else {
+      ipAddress
+    }
+
+    var ipByteArray = BigInteger.valueOf(ip.toLong()).toByteArray()
+    if (ipByteArray.size < 4) {
+      ipByteArray = frontPadWithZeros(ipByteArray)
+    }
+
+    return try {
+      InetAddress.getByAddress(ipByteArray).hostAddress as String
+    } catch (e: UnknownHostException) {
+      "0.0.0.0"
+    }
+  }
+}

package/android/src/main/java/expo/modules/network/NetworkUtils.kt

@@ -0,0 +1,52 @@
+package expo.modules.network
+
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.net.NetworkInfo
+import android.os.Build
+import android.util.Log
+
+private val TAG = NetworkModule::class.java.simpleName
+
+internal fun frontPadWithZeros(inputArray: ByteArray): ByteArray {
+  val newByteArray = byteArrayOf(0, 0, 0, 0)
+  System.arraycopy(inputArray, 0, newByteArray, 4 - inputArray.size, inputArray.size)
+  return newByteArray
+}
+
+/**
+ * Returns whether the device can reach the Internet.
+ * Checks that the active network has both the INTERNET and VALIDATED
+ * capabilities, has a usable connection state, and (for VPN connections)
+ * has non-zero downstream bandwidth.
+ */
+internal fun isInternetReachable(
+  connectivityManager: ConnectivityManager,
+  sdkInt: Int = Build.VERSION.SDK_INT
+): Boolean {
+  val network = connectivityManager.activeNetwork ?: return false
+  val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
+
+  val hasUsableConnectionState = if (sdkInt >= Build.VERSION_CODES.Q) {
+    capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED)
+  } else {
+    val networkInfo = try {
+      connectivityManager.getNetworkInfo(network)
+    } catch (e: SecurityException) {
+      Log.w(TAG, "expo-network could not read network state: missing ACCESS_NETWORK_STATE permission", e)
+      null
+    }
+    networkInfo?.detailedState == NetworkInfo.DetailedState.CONNECTED
+  }
+
+  var isReachable =
+    capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+      capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED) &&
+      hasUsableConnectionState
+
+  if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
+    isReachable = isReachable && capabilities.linkDownstreamBandwidthKbps != 0
+  }
+
+  return isReachable
+}

package/build/ExpoNetwork.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=ExpoNetwork.d.ts.map

package/build/ExpoNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoNetwork.d.ts","sourceRoot":"","sources":["../src/ExpoNetwork.ts"],"names":[],"mappings":";AAEA,wBAAkD"}

package/build/ExpoNetwork.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+export default requireNativeModule('ExpoNetwork');
+//# sourceMappingURL=ExpoNetwork.js.map

package/build/ExpoNetwork.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoNetwork.js","sourceRoot":"","sources":["../src/ExpoNetwork.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,eAAe,mBAAmB,CAAC,aAAa,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\n\nexport default requireNativeModule('ExpoNetwork');\n"]}

package/build/ExpoNetwork.web.d.ts

@@ -0,0 +1,14 @@
+import { NativeModule } from 'expo-modules-core';
+import type { NetworkEvents, NetworkState } from './Network.types';
+declare class ExpoNetworkModule extends NativeModule<NetworkEvents> {
+    eventListener?: () => void;
+    updateNetworkState(): void;
+    getIpAddressAsync(): Promise<string>;
+    getNetworkStateAsync(): Promise<NetworkState>;
+    isAirplaneModeEnabledAsync(): Promise<boolean>;
+    startObserving(): void;
+    stopObserving(): void;
+}
+declare const _default: typeof ExpoNetworkModule;
+export default _default;
+//# sourceMappingURL=ExpoNetwork.web.d.ts.map

package/build/ExpoNetwork.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoNetwork.web.d.ts","sourceRoot":"","sources":["../src/ExpoNetwork.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAqB,MAAM,mBAAmB,CAAC;AAEpE,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAcnE,cAAM,iBAAkB,SAAQ,YAAY,CAAC,aAAa,CAAC;IACzD,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B,kBAAkB;IAKZ,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IASpC,oBAAoB,IAAI,OAAO,CAAC,YAAY,CAAC;IAG7C,0BAA0B,IAAI,OAAO,CAAC,OAAO,CAAC;IAGpD,cAAc;IAKd,aAAa;CAMd;;AAED,wBAAmE"}

package/build/ExpoNetwork.web.js

@@ -0,0 +1,47 @@
+import { NativeModule, registerWebModule } from 'expo-modules-core';
+import { NetworkStateType } from './Network.types';
+const onNetworkStateEventName = 'onNetworkStateChanged';
+function getNetworkState() {
+    const isOnline = typeof navigator !== 'undefined' && navigator.onLine;
+    return {
+        type: isOnline ? NetworkStateType.UNKNOWN : NetworkStateType.NONE,
+        isConnected: isOnline,
+        isInternetReachable: isOnline,
+    };
+}
+class ExpoNetworkModule extends NativeModule {
+    eventListener;
+    updateNetworkState() {
+        const state = getNetworkState();
+        this.emit(onNetworkStateEventName, state);
+    }
+    async getIpAddressAsync() {
+        try {
+            const resp = await fetch('https://api.ipify.org?format=json');
+            const data = await resp.json();
+            return data.ip;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async getNetworkStateAsync() {
+        return getNetworkState();
+    }
+    async isAirplaneModeEnabledAsync() {
+        return false;
+    }
+    startObserving() {
+        this.eventListener = () => this.updateNetworkState();
+        window.addEventListener('online', this.eventListener);
+        window.addEventListener('offline', this.eventListener);
+    }
+    stopObserving() {
+        if (this.eventListener) {
+            window.removeEventListener('online', this.eventListener);
+            window.removeEventListener('offline', this.eventListener);
+        }
+    }
+}
+export default registerWebModule(ExpoNetworkModule, 'ExpoNetwork');
+//# sourceMappingURL=ExpoNetwork.web.js.map

package/build/ExpoNetwork.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoNetwork.web.js","sourceRoot":"","sources":["../src/ExpoNetwork.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,MAAM,uBAAuB,GAAG,uBAAuB,CAAC;AAExD,SAAS,eAAe;IACtB,MAAM,QAAQ,GAAG,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,MAAM,CAAC;IACtE,OAAO;QACL,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI;QACjE,WAAW,EAAE,QAAQ;QACrB,mBAAmB,EAAE,QAAQ;KAC9B,CAAC;AACJ,CAAC;AAED,MAAM,iBAAkB,SAAQ,YAA2B;IACzD,aAAa,CAAc;IAC3B,kBAAkB;QAChB,MAAM,KAAK,GAAG,eAAe,EAAE,CAAC;QAChC,IAAI,CAAC,IAAI,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,iBAAiB;QACrB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,mCAAmC,CAAC,CAAC;YAC9D,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,EAAE,CAAC;QACjB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IACD,KAAK,CAAC,oBAAoB;QACxB,OAAO,eAAe,EAAE,CAAC;IAC3B,CAAC;IACD,KAAK,CAAC,0BAA0B;QAC9B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,cAAc;QACZ,IAAI,CAAC,aAAa,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACrD,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACtD,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IACzD,CAAC;IACD,aAAa;QACX,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;YACzD,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;CACF;AAED,eAAe,iBAAiB,CAAC,iBAAiB,EAAE,aAAa,CAAC,CAAC","sourcesContent":["import { NativeModule, registerWebModule } from 'expo-modules-core';\n\nimport type { NetworkEvents, NetworkState } from './Network.types';\nimport { NetworkStateType } from './Network.types';\n\nconst onNetworkStateEventName = 'onNetworkStateChanged';\n\nfunction getNetworkState(): NetworkState {\n  const isOnline = typeof navigator !== 'undefined' && navigator.onLine;\n  return {\n    type: isOnline ? NetworkStateType.UNKNOWN : NetworkStateType.NONE,\n    isConnected: isOnline,\n    isInternetReachable: isOnline,\n  };\n}\n\nclass ExpoNetworkModule extends NativeModule<NetworkEvents> {\n  eventListener?: () => void;\n  updateNetworkState() {\n    const state = getNetworkState();\n    this.emit(onNetworkStateEventName, state);\n  }\n\n  async getIpAddressAsync(): Promise<string> {\n    try {\n      const resp = await fetch('https://api.ipify.org?format=json');\n      const data = await resp.json();\n      return data.ip;\n    } catch (e) {\n      throw e;\n    }\n  }\n  async getNetworkStateAsync(): Promise<NetworkState> {\n    return getNetworkState();\n  }\n  async isAirplaneModeEnabledAsync(): Promise<boolean> {\n    return false;\n  }\n  startObserving() {\n    this.eventListener = () => this.updateNetworkState();\n    window.addEventListener('online', this.eventListener);\n    window.addEventListener('offline', this.eventListener);\n  }\n  stopObserving() {\n    if (this.eventListener) {\n      window.removeEventListener('online', this.eventListener);\n      window.removeEventListener('offline', this.eventListener);\n    }\n  }\n}\n\nexport default registerWebModule(ExpoNetworkModule, 'ExpoNetwork');\n"]}

package/build/Network.d.ts

@@ -0,0 +1,80 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { NetworkState, NetworkStateEvent } from './Network.types';
+export { type NetworkState, type NetworkStateEvent, NetworkStateType } from './Network.types';
+/**
+ * Gets the device's current network connection state.
+ *
+ * On web, `navigator.connection.type` is not available on browsers. So if there is an active
+ * network connection, the field `type` returns `NetworkStateType.UNKNOWN`. Otherwise, it returns
+ * `NetworkStateType.NONE`.
+ * @return A `Promise` that fulfils with a `NetworkState` object.
+ *
+ * @example
+ * ```ts
+ * await Network.getNetworkStateAsync();
+ * // {
+ * //   type: NetworkStateType.CELLULAR,
+ * //   isConnected: true,
+ * //   isInternetReachable: true,
+ * // }
+ * ```
+ */
+export declare function getNetworkStateAsync(): Promise<NetworkState>;
+/**
+ * Gets the device's current IPv4 address. Returns `0.0.0.0` if the IP address could not be retrieved.
+ *
+ * On web, this method uses the third-party [`ipify service`](https://www.ipify.org/) to get the
+ * public IP address of the current device.
+ * @return A `Promise` that fulfils with a `string` of the current IP address of the device's main
+ * network interface. Can only be IPv4 address.
+ *
+ * @example
+ * ```ts
+ * await Network.getIpAddressAsync();
+ * // "92.168.32.44"
+ * ```
+ */
+export declare function getIpAddressAsync(): Promise<string>;
+/**
+ * Tells if the device is in airplane mode.
+ * @return Returns a `Promise` that fulfils with a `boolean` value for whether the device is in
+ * airplane mode or not.
+ * @platform android
+ *
+ * @example
+ * ```ts
+ * await Network.isAirplaneModeEnabledAsync();
+ * // false
+ * ```
+ */
+export declare function isAirplaneModeEnabledAsync(): Promise<boolean>;
+/**
+ * Adds a listener that will fire whenever the network state changes.
+ *
+ * @param listener Callback to execute when the network state changes. The callback is provided with
+ * a single argument that is an object containing information about the network state.
+ *
+ * @example
+ * ```ts
+ * const subscription = addNetworkStateListener(({ type, isConnected, isInternetReachable }) => {
+ *   console.log(`Network type: ${type}, Connected: ${isConnected}, Internet Reachable: ${isInternetReachable}`);
+ * });
+ * ```
+ *
+ * @returns A subscription object with a remove function to unregister the listener.
+ */
+export declare function addNetworkStateListener(listener: (event: NetworkStateEvent) => void): EventSubscription;
+/**
+ * Returns the current network state of the device. This method
+ * initiates a listener for network state changes and cleans up before unmounting.
+ *
+ * @example
+ * ```ts
+ * const networkState = useNetworkState();
+ * console.log(`Current network type: ${networkState.type}`);
+ * ```
+ *
+ * @return The current network state of the device, including connectivity and type.
+ */
+export declare function useNetworkState(): NetworkState;
+//# sourceMappingURL=Network.d.ts.map

package/build/Network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Network.d.ts","sourceRoot":"","sources":["../src/Network.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,mBAAmB,CAAC;AAIhF,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEvE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAK9F;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,YAAY,CAAC,CAKlE;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CAKzD;AAGD;;;;;;;;;;;GAWG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,OAAO,CAAC,CAKnE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,iBAAiB,CAEnB;AAGD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAU9C"}

package/build/Network.js

@@ -0,0 +1,111 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { useEffect, useState } from 'react';
+import ExpoNetwork from './ExpoNetwork';
+export { NetworkStateType } from './Network.types';
+const onNetworkStateEventName = 'onNetworkStateChanged';
+// @needsAudit
+/**
+ * Gets the device's current network connection state.
+ *
+ * On web, `navigator.connection.type` is not available on browsers. So if there is an active
+ * network connection, the field `type` returns `NetworkStateType.UNKNOWN`. Otherwise, it returns
+ * `NetworkStateType.NONE`.
+ * @return A `Promise` that fulfils with a `NetworkState` object.
+ *
+ * @example
+ * ```ts
+ * await Network.getNetworkStateAsync();
+ * // {
+ * //   type: NetworkStateType.CELLULAR,
+ * //   isConnected: true,
+ * //   isInternetReachable: true,
+ * // }
+ * ```
+ */
+export async function getNetworkStateAsync() {
+    if (!ExpoNetwork.getNetworkStateAsync) {
+        throw new UnavailabilityError('expo-network', 'getNetworkStateAsync');
+    }
+    return await ExpoNetwork.getNetworkStateAsync();
+}
+// @needsAudit
+/**
+ * Gets the device's current IPv4 address. Returns `0.0.0.0` if the IP address could not be retrieved.
+ *
+ * On web, this method uses the third-party [`ipify service`](https://www.ipify.org/) to get the
+ * public IP address of the current device.
+ * @return A `Promise` that fulfils with a `string` of the current IP address of the device's main
+ * network interface. Can only be IPv4 address.
+ *
+ * @example
+ * ```ts
+ * await Network.getIpAddressAsync();
+ * // "92.168.32.44"
+ * ```
+ */
+export async function getIpAddressAsync() {
+    if (!ExpoNetwork.getIpAddressAsync) {
+        throw new UnavailabilityError('expo-network', 'getIpAddressAsync');
+    }
+    return await ExpoNetwork.getIpAddressAsync();
+}
+// @needsAudit
+/**
+ * Tells if the device is in airplane mode.
+ * @return Returns a `Promise` that fulfils with a `boolean` value for whether the device is in
+ * airplane mode or not.
+ * @platform android
+ *
+ * @example
+ * ```ts
+ * await Network.isAirplaneModeEnabledAsync();
+ * // false
+ * ```
+ */
+export async function isAirplaneModeEnabledAsync() {
+    if (!ExpoNetwork.isAirplaneModeEnabledAsync) {
+        throw new UnavailabilityError('expo-network', 'isAirplaneModeEnabledAsync');
+    }
+    return await ExpoNetwork.isAirplaneModeEnabledAsync();
+}
+/**
+ * Adds a listener that will fire whenever the network state changes.
+ *
+ * @param listener Callback to execute when the network state changes. The callback is provided with
+ * a single argument that is an object containing information about the network state.
+ *
+ * @example
+ * ```ts
+ * const subscription = addNetworkStateListener(({ type, isConnected, isInternetReachable }) => {
+ *   console.log(`Network type: ${type}, Connected: ${isConnected}, Internet Reachable: ${isInternetReachable}`);
+ * });
+ * ```
+ *
+ * @returns A subscription object with a remove function to unregister the listener.
+ */
+export function addNetworkStateListener(listener) {
+    return ExpoNetwork.addListener(onNetworkStateEventName, listener);
+}
+// @needsAudit
+/**
+ * Returns the current network state of the device. This method
+ * initiates a listener for network state changes and cleans up before unmounting.
+ *
+ * @example
+ * ```ts
+ * const networkState = useNetworkState();
+ * console.log(`Current network type: ${networkState.type}`);
+ * ```
+ *
+ * @return The current network state of the device, including connectivity and type.
+ */
+export function useNetworkState() {
+    const [networkState, setNetworkState] = useState({});
+    useEffect(() => {
+        getNetworkStateAsync().then(setNetworkState);
+        const listener = addNetworkStateListener((networkState) => setNetworkState(networkState));
+        return () => listener.remove();
+    }, []);
+    return networkState;
+}
+//# sourceMappingURL=Network.js.map

package/build/Network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Network.js","sourceRoot":"","sources":["../src/Network.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAE5C,OAAO,WAAW,MAAM,eAAe,CAAC;AAGxC,OAAO,EAA6C,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE9F,MAAM,uBAAuB,GAAG,uBAAuB,CAAC;AAExD,cAAc;AACd;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB;IACxC,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;QACtC,MAAM,IAAI,mBAAmB,CAAC,cAAc,EAAE,sBAAsB,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,MAAM,WAAW,CAAC,oBAAoB,EAAE,CAAC;AAClD,CAAC;AAED,cAAc;AACd;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACnC,MAAM,IAAI,mBAAmB,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;AAC/C,CAAC;AAED,cAAc;AACd;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B;IAC9C,IAAI,CAAC,WAAW,CAAC,0BAA0B,EAAE,CAAC;QAC5C,MAAM,IAAI,mBAAmB,CAAC,cAAc,EAAE,4BAA4B,CAAC,CAAC;IAC9E,CAAC;IACD,OAAO,MAAM,WAAW,CAAC,0BAA0B,EAAE,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB,CACrC,QAA4C;IAE5C,OAAO,WAAW,CAAC,WAAW,CAAC,uBAAuB,EAAE,QAAQ,CAAC,CAAC;AACpE,CAAC;AAED,cAAc;AACd;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe;IAC7B,MAAM,CAAC,YAAY,EAAE,eAAe,CAAC,GAAG,QAAQ,CAAe,EAAE,CAAC,CAAC;IAEnE,SAAS,CAAC,GAAG,EAAE;QACb,oBAAoB,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC7C,MAAM,QAAQ,GAAG,uBAAuB,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;QAC1F,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IACjC,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO,YAAY,CAAC;AACtB,CAAC","sourcesContent":["import { type EventSubscription, UnavailabilityError } from 'expo-modules-core';\nimport { useEffect, useState } from 'react';\n\nimport ExpoNetwork from './ExpoNetwork';\nimport type { NetworkState, NetworkStateEvent } from './Network.types';\n\nexport { type NetworkState, type NetworkStateEvent, NetworkStateType } from './Network.types';\n\nconst onNetworkStateEventName = 'onNetworkStateChanged';\n\n// @needsAudit\n/**\n * Gets the device's current network connection state.\n *\n * On web, `navigator.connection.type` is not available on browsers. So if there is an active\n * network connection, the field `type` returns `NetworkStateType.UNKNOWN`. Otherwise, it returns\n * `NetworkStateType.NONE`.\n * @return A `Promise` that fulfils with a `NetworkState` object.\n *\n * @example\n * ```ts\n * await Network.getNetworkStateAsync();\n * // {\n * //   type: NetworkStateType.CELLULAR,\n * //   isConnected: true,\n * //   isInternetReachable: true,\n * // }\n * ```\n */\nexport async function getNetworkStateAsync(): Promise<NetworkState> {\n  if (!ExpoNetwork.getNetworkStateAsync) {\n    throw new UnavailabilityError('expo-network', 'getNetworkStateAsync');\n  }\n  return await ExpoNetwork.getNetworkStateAsync();\n}\n\n// @needsAudit\n/**\n * Gets the device's current IPv4 address. Returns `0.0.0.0` if the IP address could not be retrieved.\n *\n * On web, this method uses the third-party [`ipify service`](https://www.ipify.org/) to get the\n * public IP address of the current device.\n * @return A `Promise` that fulfils with a `string` of the current IP address of the device's main\n * network interface. Can only be IPv4 address.\n *\n * @example\n * ```ts\n * await Network.getIpAddressAsync();\n * // \"92.168.32.44\"\n * ```\n */\nexport async function getIpAddressAsync(): Promise<string> {\n  if (!ExpoNetwork.getIpAddressAsync) {\n    throw new UnavailabilityError('expo-network', 'getIpAddressAsync');\n  }\n  return await ExpoNetwork.getIpAddressAsync();\n}\n\n// @needsAudit\n/**\n * Tells if the device is in airplane mode.\n * @return Returns a `Promise` that fulfils with a `boolean` value for whether the device is in\n * airplane mode or not.\n * @platform android\n *\n * @example\n * ```ts\n * await Network.isAirplaneModeEnabledAsync();\n * // false\n * ```\n */\nexport async function isAirplaneModeEnabledAsync(): Promise<boolean> {\n  if (!ExpoNetwork.isAirplaneModeEnabledAsync) {\n    throw new UnavailabilityError('expo-network', 'isAirplaneModeEnabledAsync');\n  }\n  return await ExpoNetwork.isAirplaneModeEnabledAsync();\n}\n\n/**\n * Adds a listener that will fire whenever the network state changes.\n *\n * @param listener Callback to execute when the network state changes. The callback is provided with\n * a single argument that is an object containing information about the network state.\n *\n * @example\n * ```ts\n * const subscription = addNetworkStateListener(({ type, isConnected, isInternetReachable }) => {\n *   console.log(`Network type: ${type}, Connected: ${isConnected}, Internet Reachable: ${isInternetReachable}`);\n * });\n * ```\n *\n * @returns A subscription object with a remove function to unregister the listener.\n */\nexport function addNetworkStateListener(\n  listener: (event: NetworkStateEvent) => void\n): EventSubscription {\n  return ExpoNetwork.addListener(onNetworkStateEventName, listener);\n}\n\n// @needsAudit\n/**\n * Returns the current network state of the device. This method\n * initiates a listener for network state changes and cleans up before unmounting.\n *\n * @example\n * ```ts\n * const networkState = useNetworkState();\n * console.log(`Current network type: ${networkState.type}`);\n * ```\n *\n * @return The current network state of the device, including connectivity and type.\n */\nexport function useNetworkState(): NetworkState {\n  const [networkState, setNetworkState] = useState<NetworkState>({});\n\n  useEffect(() => {\n    getNetworkStateAsync().then(setNetworkState);\n    const listener = addNetworkStateListener((networkState) => setNetworkState(networkState));\n    return () => listener.remove();\n  }, []);\n\n  return networkState;\n}\n"]}