@amazon-devices/expo-network 2.0.9000000000 → 3.0.0

package/ios/NetworkModule.swift

@@ -1,102 +0,0 @@
-import ExpoModulesCore
-import SystemConfiguration
-import Network
-
-public final class NetworkModule: Module {
-  private let monitor = NWPathMonitor()
-  private let monitorQueue = DispatchQueue.global(qos: .default)
-
-  public func definition() -> ModuleDefinition {
-    Name("ExpoNetwork")
-
-    OnCreate {
-      monitor.start(queue: monitorQueue)
-    }
-
-    AsyncFunction("getIpAddressAsync") { () -> String? in
-      return try getIPAddress()
-    }
-
-    AsyncFunction("getNetworkStateAsync") {
-      return getNetworkStateAsync()
-    }
-
-    OnDestroy {
-      monitor.cancel()
-    }
-  }
-
-  private func getIPAddress() throws -> String {
-    var address = "0.0.0.0"
-    var ifaddr: UnsafeMutablePointer<ifaddrs>?
-
-    let error = getifaddrs(&ifaddr)
-
-    guard error == 0 else {
-      throw IpAddressException(error)
-    }
-
-    guard let firstAddr = ifaddr else {
-      return address
-    }
-
-    for ifptr in sequence(first: firstAddr, next: { $0.pointee.ifa_next }) {
-      let temp = ifptr.pointee
-      let family = temp.ifa_addr.pointee.sa_family
-
-      if family == UInt8(AF_INET) {
-        let name = String(cString: temp.ifa_name)
-        if name == "en0" || name == "en1" {
-          var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
-          getnameinfo(
-            temp.ifa_addr,
-            socklen_t(temp.ifa_addr.pointee.sa_len),
-            &hostname,
-            socklen_t(hostname.count),
-            nil,
-            socklen_t(0),
-            NI_NUMERICHOST)
-          address = String(cString: hostname)
-        }
-      }
-    }
-
-    freeifaddrs(ifaddr)
-    return address
-  }
-
-  private func getNetworkStateAsync() -> [String: Any] {
-    let path = monitor.currentPath
-    let isConnected = path.status == .satisfied
-    var currentNetworkType = NetworkType.unknown
-
-    if !isConnected {
-      return [
-        "type": NetworkType.none.description,
-        "isConnected": isConnected,
-        "isInternetReachable": isConnected
-      ]
-    }
-
-    let connectionType = NWInterface
-      .InterfaceType
-      .allCases
-      .filter { path.usesInterfaceType($0) }
-      .first
-
-    switch connectionType {
-    case .wifi:
-      currentNetworkType = .wifi
-    case .cellular:
-      currentNetworkType = .cellular
-    default:
-      currentNetworkType = .unknown
-    }
-
-    return [
-      "type": currentNetworkType.description,
-      "isConnected": isConnected,
-      "isInternetReachable": isConnected
-    ]
-  }
-}

package/ios/NetworkType.swift

@@ -1,28 +0,0 @@
-import Network
-
-extension NWInterface.InterfaceType: CaseIterable {
-  public static var allCases: [NWInterface.InterfaceType] = [
-    .other,
-    .wifi,
-    .cellular,
-    .loopback,
-    .wiredEthernet
-  ]
-}
-
-enum NetworkType: CustomStringConvertible {
-  case unknown, wifi, none, cellular
-
-  var description: String {
-    switch self {
-    case .wifi:
-      return "WIFI"
-    case .cellular:
-      return "CELLULAR"
-    case .unknown:
-      return "UNKNOWN"
-    case .none:
-      return "NONE"
-    }
-  }
-}

package/kepler/ExpoNetwork.cpp

@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * PROPRIETARY/CONFIDENTIAL
- *
- * Use is subject to license terms.
- */
-
-#include "ExpoNetwork.h"
-
-#include <KeplerScript/logger/KPLog.h>
-
-#include "NetworkInterfaces.h"
-
-ExpoNetwork::ExpoNetwork() : volta::react::KeplerTurboModule("ExpoNetwork") {
-    volta::react::KPLog.debug("ExpoNetwork constructor {}", name());
-}
-
-volta::react::Promise ExpoNetwork::getIpAddressAsync() {
-    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
-        auto interfaces = NetworkInterfaces();
-        promise->resolve(interfaces.wlanInterfaceAddress());
-    });
-}
-
-volta::react::Promise ExpoNetwork::getNetworkStateAsync() {
-    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
-        try {
-            auto interfaces = NetworkInterfaces();
-            bool isConnected = interfaces.isNetworkConnected();
-
-            auto networkState = utils::json::JsonContainer::createJsonObject();
-            networkState.insert("isConnected", isConnected);
-            networkState.insert("type", isConnected ? 3 : 0);
-
-            promise->resolve(networkState);
-        } catch (std::exception& e) {
-            volta::react::KPLog.debug("Can't get network state: {}", std::string(e.what()));
-            promise->reject(std::string{"Can't get network state: " + std::string(e.what())});
-        }
-    });
-}
-
-volta::react::Promise ExpoNetwork::isAirplaneModeEnabledAsync() {
-    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) { promise->resolve(false); });
-}
-
-void ExpoNetwork::aggregateMethods(
-        volta::react::MethodAggregator<volta::react::KeplerTurboModule>& methodAggregator) const noexcept {
-    volta::react::KPLog.debug("methodAggregator");
-
-    methodAggregator.addMethod("getNetworkStateAsync", 0, &ExpoNetwork::getNetworkStateAsync);
-    methodAggregator.addMethod("getIpAddressAsync", 0, &ExpoNetwork::getIpAddressAsync);
-    methodAggregator.addMethod("isAirplaneModeEnabledAsync", 0, &ExpoNetwork::isAirplaneModeEnabledAsync);
-}

package/kepler/ExpoNetwork.h

@@ -1,24 +0,0 @@
-/*
- * Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * PROPRIETARY/CONFIDENTIAL
- *
- * Use is subject to license terms.
- */
-
-#include <KeplerScript/modules/KeplerTurboModule.h>
-
-class KEPLERSCRIPT_EXPORT ExpoNetwork : public volta::react::KeplerTurboModule {
-public:
-    ExpoNetwork();
-
-#ifndef UNIT_TEST
-protected:
-#endif
-    volta::react::Promise getIpAddressAsync();
-    volta::react::Promise getNetworkStateAsync();
-    volta::react::Promise isAirplaneModeEnabledAsync();
-
-    void aggregateMethods(
-            volta::react::MethodAggregator<volta::react::KeplerTurboModule>& methodAggregator) const noexcept override;
-};

package/kepler/KeplerInit.cpp

@@ -1,28 +0,0 @@
-/*
- * 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

@@ -1,74 +0,0 @@
-/*
- * 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

@@ -1,20 +0,0 @@
-/*
- * 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

@@ -1,147 +0,0 @@
-/*
- * 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/src/ExpoNetwork.kepler.ts

@@ -1,80 +0,0 @@
-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

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

package/src/ExpoNetwork.web.ts

@@ -1,21 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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();
-}