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

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ohos-ports/expo-network",
+  "version": "57.0.2-beta.0",
+  "description": "Provides useful information about the device's network such as its IP address, MAC address, and airplane mode status",
+  "main": "build/Network.js",
+  "types": "build/Network.d.ts",
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-network"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/expo-network/57.0.2"
+  },
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "author": "650 Industries, Inc.",
+  "license": "MIT",
+  "homepage": "https://docs.expo.dev/versions/latest/sdk/network/",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.2.0",
+    "@ohos-ports/expo": "^57.0.24-beta.0",
+    "expo-module-scripts": "56.0.3"
+  },
+  "peerDependencies": {
+    "@ohos-ports/expo": "^57.0.24-beta.0",
+    "react": "*"
+  },
+  "gitHead": "9e5319c0f821a27b7924841903abae50e2b41790",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "expo-module": "expo-module"
+  }
+}

package/spm.config.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "../../tools/src/prebuilds/schemas/spm.config.schema.json",
+  "products": [
+    {
+      "name": "ExpoNetwork",
+      "podName": "ExpoNetwork",
+      "platforms": [
+        "iOS(\"16.4\")"
+      ],
+      "externalDependencies": [
+        "ReactNativeDependencies",
+        "React",
+        "Hermes",
+        "expo-modules-core/ExpoModulesCore"
+      ],
+      "targets": [
+        {
+          "type": "swift",
+          "name": "ExpoNetwork",
+          "path": "ios",
+          "pattern": "*.swift",
+          "dependencies": [
+            "Hermes",
+            "React",
+            "ReactNativeDependencies",
+            "expo-modules-core/ExpoModulesCore"
+          ],
+          "linkedFrameworks": [
+            "Foundation",
+            "SystemConfiguration",
+            "Network"
+          ]
+        }
+      ]
+    }
+  ]
+}

package/src/ExpoNetwork.ts

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+export default requireNativeModule('ExpoNetwork');

package/src/ExpoNetwork.web.ts

@@ -0,0 +1,52 @@
+import { NativeModule, registerWebModule } from 'expo-modules-core';
+
+import type { NetworkEvents, NetworkState } from './Network.types';
+import { NetworkStateType } from './Network.types';
+
+const onNetworkStateEventName = 'onNetworkStateChanged';
+
+function getNetworkState(): NetworkState {
+  const isOnline = typeof navigator !== 'undefined' && navigator.onLine;
+  return {
+    type: isOnline ? NetworkStateType.UNKNOWN : NetworkStateType.NONE,
+    isConnected: isOnline,
+    isInternetReachable: isOnline,
+  };
+}
+
+class ExpoNetworkModule extends NativeModule<NetworkEvents> {
+  eventListener?: () => void;
+  updateNetworkState() {
+    const state = getNetworkState();
+    this.emit(onNetworkStateEventName, state);
+  }
+
+  async getIpAddressAsync(): Promise<string> {
+    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(): Promise<NetworkState> {
+    return getNetworkState();
+  }
+  async isAirplaneModeEnabledAsync(): Promise<boolean> {
+    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');

package/src/Network.ts

@@ -0,0 +1,123 @@
+import { type EventSubscription, UnavailabilityError } from 'expo-modules-core';
+import { useEffect, useState } from 'react';
+
+import ExpoNetwork from './ExpoNetwork';
+import type { NetworkState, NetworkStateEvent } from './Network.types';
+
+export { type NetworkState, type NetworkStateEvent, 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(): Promise<NetworkState> {
+  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(): Promise<string> {
+  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(): Promise<boolean> {
+  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: (event: NetworkStateEvent) => void
+): EventSubscription {
+  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(): NetworkState {
+  const [networkState, setNetworkState] = useState<NetworkState>({});
+
+  useEffect(() => {
+    getNetworkStateAsync().then(setNetworkState);
+    const listener = addNetworkStateListener((networkState) => setNetworkState(networkState));
+    return () => listener.remove();
+  }, []);
+
+  return networkState;
+}

package/src/Network.types.ts

@@ -0,0 +1,90 @@
+// @needsAudit
+export type NetworkState = {
+  /**
+   * A [`NetworkStateType`](#networkstatetype) enum value that represents the current network
+   * connection type.
+   */
+  type?: NetworkStateType;
+  /**
+   * If there is an active network connection. Note that this does not mean that internet is reachable.
+   * This field is `false` if the type is either `Network.NetworkStateType.NONE` or `Network.NetworkStateType.UNKNOWN`,
+   * `true` otherwise.
+   */
+  isConnected?: boolean;
+  /**
+   * If the internet is reachable with the currently active network connection. On Android, this
+   * requires the active network to have internet capability (`NET_CAPABILITY_INTERNET`), confirmed
+   * internet access (`NET_CAPABILITY_VALIDATED`), and a usable connection state. VPN connections
+   * also require non-zero downstream bandwidth. On iOS, this value will always be the same as
+   * `isConnected`.
+   */
+  isInternetReachable?: boolean;
+};
+
+// @needsAudit
+/**
+ * An enum of the different types of devices supported by Expo.
+ */
+export enum NetworkStateType {
+  /**
+   * No active network connection detected.
+   */
+  NONE = 'NONE',
+  /**
+   * The connection type could not be determined.
+   */
+  UNKNOWN = 'UNKNOWN',
+  /**
+   * Active network connection over mobile data or [`DUN-specific`](https://developer.android.com/reference/android/net/ConnectivityManager#TYPE_MOBILE_DUN)
+   * mobile connection when setting an upstream connection for tethering.
+   * @platform android
+   * @platform ios
+   */
+  CELLULAR = 'CELLULAR',
+  /**
+   * Active network connection over Wi-Fi.
+   * @platform android
+   * @platform ios
+   */
+  WIFI = 'WIFI',
+  /**
+   * Active network connection over Bluetooth.
+   * @platform android
+   */
+  BLUETOOTH = 'BLUETOOTH',
+  /**
+   * Active network connection over Ethernet.
+   * @platform android
+   * @platform ios
+   */
+  ETHERNET = 'ETHERNET',
+  /**
+   * Active network connection over WiMAX.
+   * @platform android
+   */
+  WIMAX = 'WIMAX',
+  /**
+   * Active network connection over VPN.
+   * @platform android
+   */
+  VPN = 'VPN',
+  /**
+   * Active network connection over other network connection types.
+   * @platform android
+   */
+  OTHER = 'OTHER',
+}
+
+// @needsAudit
+/**
+ * Represents an event that provides the updated network state when there is a change in the network status.
+ * This is passed as the argument to listeners registered with [`addNetworkStateListener()`](#networkaddnetworkstatelistenerlistener).
+ */
+export type NetworkStateEvent = NetworkState;
+
+/**
+ * @hidden
+ */
+export type NetworkEvents = {
+  onNetworkStateChanged(event: NetworkStateEvent): void;
+};

package/tsconfig.json

@@ -0,0 +1,10 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__rsc_tests__/*"]
+}