@amazon-devices/expo-network 2.0.1758683737

package/kepler/KeplerInit.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <KeplerScript/logger/KPLog.h>
+#include <KeplerScript/utils/autolink/KeplerAutoLinkInfo.h>
+#include <keplerui-072/keplerscript-export.h>
+
+#include "ExpoNetwork.h"
+#include "RegisterModule.h"
+
+extern "C" {
+KEPLERSCRIPT_EXPORT void keplerAutoLinkInitV1(const kepler::autolink::v1::KeplerAutoLinkInfo* autoLinkInfo) noexcept {
+    volta::react::KPLog.debug("keplerAutoLinkInitV1 for ExpoNetwork");
+
+    REGISTER_MODULE(autoLinkInfo, ExpoNetwork, "ExpoNetwork");
+
+    volta::react::KPLog.debug("after registering module");
+}
+}
+
+int main() {
+    return 0;
+}

package/kepler/NetworkInterfaces.cpp

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "NetworkInterfaces.h"
+
+#include <KeplerScript/logger/KPLog.h>
+#include <arpa/inet.h>
+#include <ifaddrs.h>
+#include <linux/if_link.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+namespace {
+const std::string unresolvedAddress = "0.0.0.0";
+const std::string wlanInterfaceName = "wlan0";
+}  // namespace
+
+NetworkInterfaces::NetworkInterfaces() {
+    if (getifaddrs(&ifaddr) == -1) {
+        throw std::runtime_error("network interfaces info failed to fetch.");
+    }
+}
+
+NetworkInterfaces::~NetworkInterfaces() {
+    freeifaddrs(ifaddr);
+}
+
+std::string NetworkInterfaces::wlanInterfaceAddress() {
+    try {
+        char host[NI_MAXHOST];
+
+        for (auto* ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
+            if (ifa->ifa_addr == nullptr) {
+                continue;
+            }
+
+            auto ifFamily = ifa->ifa_addr->sa_family;
+            if (ifFamily == AF_INET && std::string(ifa->ifa_name) == wlanInterfaceName) {
+                auto nameInfo = getnameinfo(
+                        ifa->ifa_addr,
+                        sizeof(struct sockaddr_in),
+                        host,
+                        NI_MAXHOST,
+                        nullptr,
+                        0,
+                        NI_NUMERICHOST);
+                if (nameInfo != 0) {
+                    throw std::runtime_error("wlan interface info failed to fetch.");
+                }
+
+                return std::string(host);
+            }
+        }
+
+        volta::react::KPLog.error("No wlan interface found.");
+    } catch (std::exception& e) {
+        volta::react::KPLog.error("Can't get ip address: {}", std::string(e.what()));
+    }
+
+    return unresolvedAddress;
+}
+
+bool NetworkInterfaces::isNetworkConnected() {
+    return wlanInterfaceAddress() != unresolvedAddress;
+}

package/kepler/NetworkInterfaces.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <string>
+
+class NetworkInterfaces {
+public:
+    NetworkInterfaces();
+    ~NetworkInterfaces();
+    std::string wlanInterfaceAddress();
+    bool isNetworkConnected();
+
+private:
+    struct ifaddrs* ifaddr;
+};

package/kepler/test/Network.cpp

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <iostream>
+
+#include "../ExpoNetwork.h"
+#include "JSObjectsConversion.h"
+#include "catch.hpp"
+
+namespace {
+bool isValidIPv4Address(const std::string& s) {
+    std::stringstream ss(s);
+    std::string segment;
+    int segmentCount = 0;
+
+    while (std::getline(ss, segment, '.')) {
+        ++segmentCount;
+
+        if (segment.empty() || segment.length() > 3 || !std::all_of(segment.begin(), segment.end(), ::isdigit) ||
+            stoi(segment) > 255 || (segment[0] == '0' && segment.length() > 1)) {
+            return false;
+        }
+    }
+
+    return segmentCount == 4;
+}
+
+void handlePromiseRejection(volta::react::NativeJSObject payload) {
+    std::string rejectionMessage = std::get<std::string>(payload["message"]);
+    FAIL(rejectionMessage);
+}
+
+enum NetworkState {
+    NONE = 0,
+    WIFI = 3,
+};
+}  // namespace
+
+SCENARIO("Testing Expo Network module") {
+    GIVEN("Expo Network module") {
+        ExpoNetwork networkModule;
+
+        // Unable to test due to lack of 'Promise' support
+        // WHEN("getIpAddressAsync is called") {
+        //     auto promise = networkModule.getIpAddressAsync();
+
+        //     promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+        //             volta::react::Callback([](auto args) {
+        //                 THEN("Resolved promise contains valid IP") {
+        //                     REQUIRE(args.size() == 1);
+        //                     REQUIRE(std::holds_alternative<std::string>(args[0]));
+
+        //                     auto ipAddress = std::get<std::string>(args[0]);
+
+        //                     REQUIRE(isValidIPv4Address(ipAddress));
+        //                 }
+        //             }),
+        //             volta::react::Callback([](auto args) {
+        //                 volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+        //                         std::get<utils::json::JsonContainer>(args[0]));
+        //                 handlePromiseRejection(payload);
+        //             })));
+        // }
+
+        // Unable to test due to lack of 'Promise' support
+        // WHEN("getNetworkStateAsync is called") {
+        //     auto promise = networkModule.getNetworkStateAsync();
+
+        //     promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+        //             volta::react::Callback([](auto args) {
+        //                 THEN("Resolved promise contains valid network state object") {
+        //                     REQUIRE(args.size() == 1);
+        //                     REQUIRE(std::holds_alternative<utils::json::JsonContainer>(args[0]));
+
+        //                     volta::react::NativeJSObject networkState =
+        //                     ExpoUtils::convertJsonContainerToNativeJSObject(
+        //                             std::get<utils::json::JsonContainer>(args[0]));
+
+        //                     REQUIRE(std::holds_alternative<int32_t>(networkState["type"]));
+        //                     REQUIRE(std::holds_alternative<bool>(networkState["isConnected"]));
+
+        //                     auto type = std::get<int32_t>(networkState["type"]);
+        //                     auto isConnected = std::get<bool>(networkState["isConnected"]);
+
+        //                     if (isConnected) {
+        //                         REQUIRE(type == WIFI);
+        //                     } else {
+        //                         REQUIRE(type == NONE);
+        //                     }
+        //                 }
+        //             }),
+        //             volta::react::Callback([](auto args) {
+        //                 volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+        //                         std::get<utils::json::JsonContainer>(args[0]));
+        //                 handlePromiseRejection(payload);
+        //             })));
+        // }
+
+        // Unable to test due to lack of 'Promise' support
+        // WHEN("isAirplaneModeEnabledAsync is called") {
+        //     auto promise = networkModule.isAirplaneModeEnabledAsync();
+
+        //     promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+        //             volta::react::Callback([](auto args) {
+        //                 THEN("Resolved promise contains false boolean") {
+        //                     REQUIRE(args.size() == 1);
+        //                     REQUIRE(std::holds_alternative<bool>(args[0]));
+
+        //                     auto isAirplaneModeEnabled = std::get<bool>(args[0]);
+        //                     REQUIRE_FALSE(isAirplaneModeEnabled);
+        //                 }
+        //             }),
+        //             volta::react::Callback([](auto args) {
+        //                 volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+        //                         std::get<utils::json::JsonContainer>(args[0]));
+        //                 handlePromiseRejection(payload);
+        //             })));
+        // }
+
+        WHEN("aggregateMethods is called") {
+            std::weak_ptr<facebook::react::Instance> instance;
+            networkModule.triggerMethodAggregation(*networkModule.jsQueue_, instance);
+
+            THEN("methodContainerMap contains expected methods") {
+                REQUIRE(networkModule.methodContainerMap_.find("getIpAddressAsync") !=
+                        networkModule.methodContainerMap_.end());
+                REQUIRE(networkModule.methodContainerMap_.find("getNetworkStateAsync") !=
+                        networkModule.methodContainerMap_.end());
+                REQUIRE(networkModule.methodContainerMap_.find("isAirplaneModeEnabledAsync") !=
+                        networkModule.methodContainerMap_.end());
+            }
+
+            THEN("size of methodContainerMap is increased by addListener and removeListeners") {
+                REQUIRE(networkModule.methodContainerMap_.size() == 5);
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1 @@
+{"name": "@amazon-devices/expo-network", "version": "2.0.1758683737+5.7.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", "scripts": {"build": "expo-module build", "clean": "expo-module clean", "lint": "expo-module lint", "test": "expo-module test", "expo-module": "expo-module"}, "kepler": {"temporary-alias-for-package": {"name": "expo-network", "version": "5.7.0"}}, "keywords": ["react-native", "expo", "expo-network"], "repository": {"type": "git", "url": "https://github.com/expo/expo.git", "directory": "packages/expo-network"}, "bugs": {"url": "https://github.com/expo/expo/issues"}, "author": "650 Industries, Inc.", "license": "See license in LICENSE", "homepage": "https://docs.expo.dev/versions/latest/sdk/network/", "dependencies": {"@amazon-devices/keplerscript-turbomodule-api": "^1.0.0"}, "devDependencies": {"expo-module-scripts": "^3.0.0"}, "peerDependencies": {"expo": "*"}, "jest": {"preset": "expo-module-scripts"}}

package/react-native.config.js

@@ -0,0 +1,21 @@
+module.exports = {
+    dependencies: {
+        '@amazon-devices/react-native-kepler': {
+            platforms: {
+                kepler: null,  // do not use platform definition from @react-native-kepler
+            },
+        },
+    },
+    dependency: {
+        platforms: {
+            kepler: {
+                autolink: {
+                    ExpoNetworkLib: {
+                        provider: 'system',
+                        turbomodules: ['ExpoNetwork'],
+                    },
+                },
+            },
+        },
+    },
+};

package/src/ExpoNetwork.kepler.ts

@@ -0,0 +1,80 @@
+import {KeplerTurboModule, TurboModuleRegistry} from '@amazon-devices/keplerscript-turbomodule-api';
+import {NetworkState, NetworkStateType} from './Network.types';
+
+export {NetworkState, NetworkStateType};
+
+type NativeModuleNetworkState = {
+    isConnected: boolean; isInternetReachable: boolean; type: number;
+};
+
+interface Spec extends KeplerTurboModule {
+    getNetworkStateAsync(): Promise<NativeModuleNetworkState>;
+    getIpAddressAsync(): Promise<string>;
+    isAirplaneModeEnabledAsync(): Promise<boolean>;
+}
+
+const nativeModule = TurboModuleRegistry.getEnforcing<Spec>('ExpoNetwork') as Spec;
+
+const networkStateNumberToType = (num: number): NetworkStateType => {
+    switch (num) {
+        case 0:
+            return NetworkStateType.NONE;
+        case 1:
+            return NetworkStateType.UNKNOWN;
+        case 2:
+            return NetworkStateType.CELLULAR;
+        case 3:
+            return NetworkStateType.WIFI;
+        case 4:
+            return NetworkStateType.BLUETOOTH;
+        case 5:
+            return NetworkStateType.ETHERNET;
+        case 6:
+            return NetworkStateType.WIMAX;
+        case 7:
+            return NetworkStateType.VPN;
+        case 8:
+            return NetworkStateType.OTHER;
+        default:
+            return NetworkStateType.UNKNOWN;
+    }
+};
+
+async function fetchWithTimeout(url: string) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), 800);
+
+    const response = await fetch(url, {signal: controller.signal});
+    clearTimeout(id);
+
+    return response;
+}
+
+const module = {
+    async getNetworkStateAsync(): Promise<NetworkState> {
+        const state = await nativeModule.getNetworkStateAsync();
+
+        let dnsResponseReceived = false;
+        try {
+            const response = await fetchWithTimeout('https://dns.google/');
+            dnsResponseReceived = !!response?.ok;
+        } catch (error) {
+            dnsResponseReceived = false;
+            console.error(error)
+        }
+
+        return {
+            type: networkStateNumberToType(state.type),
+            isConnected: state.isConnected,
+            isInternetReachable: dnsResponseReceived,
+        };
+    },
+    async getIpAddressAsync(): Promise<string> {
+        return nativeModule.getIpAddressAsync();
+    },
+    async isAirplaneModeEnabledAsync(): Promise<boolean> {
+        return nativeModule.isAirplaneModeEnabledAsync();
+    },
+};
+
+export default module;

package/src/ExpoNetwork.ts

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

package/src/ExpoNetwork.web.ts

@@ -0,0 +1,21 @@
+import { NetworkState, NetworkStateType } from './Network.types';
+
+export default {
+  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> {
+    const isOnline = typeof navigator !== 'undefined' && navigator.onLine;
+    return {
+      type: isOnline ? NetworkStateType.UNKNOWN : NetworkStateType.NONE,
+      isConnected: isOnline,
+      isInternetReachable: isOnline,
+    };
+  },
+};

package/src/Network.ts

@@ -0,0 +1,74 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import ExpoNetwork from './ExpoNetwork';
+import { NetworkState, NetworkStateType } from './Network.types';
+
+export { NetworkState, NetworkStateType };
+
+// @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();
+}

package/src/Network.types.ts

@@ -0,0 +1,64 @@
+// @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
+   * depends on `NetInfo.isConnected()` (API level < 29) or `ConnectivityManager.getActiveNetwork()`
+   * (API level >= 29). 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.
+   */
+  CELLULAR = 'CELLULAR',
+  /**
+   * Active network connection over WiFi.
+   */
+  WIFI = 'WIFI',
+  /**
+   * Active network connection over Bluetooth.
+   */
+  BLUETOOTH = 'BLUETOOTH',
+  /**
+   * Active network connection over Ethernet.
+   */
+  ETHERNET = 'ETHERNET',
+  /**
+   * Active network connection over Wimax.
+   */
+  WIMAX = 'WIMAX',
+  /**
+   * Active network connection over VPN.
+   */
+  VPN = 'VPN',
+  /**
+   * Active network connection over other network connection types.
+   */
+  OTHER = 'OTHER',
+}

package/tsconfig.json

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