@react-native-community/netinfo

  • Version 6.0.0
  • Published
  • 479 kB
  • No dependencies
  • MIT license

Install

npm i @react-native-community/netinfo
yarn add @react-native-community/netinfo
pnpm add @react-native-community/netinfo

Overview

React Native Network Info API for iOS & Android

Index

Variables

variable _default

const _default: {
configure: typeof configure;
fetch: typeof fetch;
addEventListener: typeof addEventListener;
useNetInfo: typeof useNetInfo;
};

    Functions

    function addEventListener

    addEventListener: (
    listener: Types.NetInfoChangeHandler
    ) => Types.NetInfoSubscription;
    • Subscribe to connection information. The callback is called with a parameter of type [NetInfoState](README.md#netinfostate) whenever the connection state changes. Your listener will be called with the latest information soon after you subscribe and then with any subsequent changes afterwards. You should not assume that the listener is called in the same way across devices or platforms.

      Parameter listener

      The listener which is called when the network state changes.

      Returns

      A function which can be called to unsubscribe.

    function configure

    configure: (configuration: Partial<Types.NetInfoConfiguration>) => void;
    • Configures the library with the given configuration. Note that calling this will stop all previously added listeners from being called again. It is best to call this right when your application is started to avoid issues.

      Parameter configuration

      The new configuration to set.

    function fetch

    fetch: (requestedInterface?: string) => Promise<Types.NetInfoState>;
    • Returns a Promise that resolves to a NetInfoState object.

      Parameter requestedInterface

      interface from which to obtain the information

      Returns

      A Promise which contains the current connection state.

    function useNetInfo

    useNetInfo: (
    configuration?: Partial<Types.NetInfoConfiguration>
    ) => Types.NetInfoState;
    • A React Hook which updates when the connection state changes.

      Returns

      The connection state.

    Interfaces

    interface NetInfoConfiguration

    interface NetInfoConfiguration {}

      property reachabilityLongTimeout

      reachabilityLongTimeout: number;

        property reachabilityRequestTimeout

        reachabilityRequestTimeout: number;

          property reachabilityShortTimeout

          reachabilityShortTimeout: number;

            property reachabilityTest

            reachabilityTest: (response: Response) => Promise<boolean>;

              property reachabilityUrl

              reachabilityUrl: string;

                interface NetInfoConnectedDetails

                interface NetInfoConnectedDetails {}

                  property isConnectionExpensive

                  isConnectionExpensive: boolean;

                    interface NetInfoUnknownState

                    interface NetInfoUnknownState {}

                      property details

                      details: null;

                        property isConnected

                        isConnected: null;

                          property isInternetReachable

                          isInternetReachable: null;

                            property type

                            type: NetInfoStateType.unknown;

                              Enums

                              enum NetInfoCellularGeneration

                              enum NetInfoCellularGeneration {
                              '2g' = '2g',
                              '3g' = '3g',
                              '4g' = '4g',
                              }

                                member '2g'

                                '2g' = '2g'

                                  member '3g'

                                  '3g' = '3g'

                                    member '4g'

                                    '4g' = '4g'

                                      enum NetInfoStateType

                                      enum NetInfoStateType {
                                      unknown = 'unknown',
                                      none = 'none',
                                      cellular = 'cellular',
                                      wifi = 'wifi',
                                      bluetooth = 'bluetooth',
                                      ethernet = 'ethernet',
                                      wimax = 'wimax',
                                      vpn = 'vpn',
                                      other = 'other',
                                      }
                                      • Copyright (c) Facebook, Inc. and its affiliates.

                                        This source code is licensed under the MIT license found in the LICENSE file in the root directory of this source tree.

                                      member bluetooth

                                      bluetooth = 'bluetooth'

                                        member cellular

                                        cellular = 'cellular'

                                          member ethernet

                                          ethernet = 'ethernet'

                                            member none

                                            none = 'none'

                                              member other

                                              other = 'other'

                                                member unknown

                                                unknown = 'unknown'

                                                  member vpn

                                                  vpn = 'vpn'

                                                    member wifi

                                                    wifi = 'wifi'

                                                      member wimax

                                                      wimax = 'wimax'

                                                        Type Aliases

                                                        type NetInfoBluetoothState

                                                        type NetInfoBluetoothState = NetInfoConnectedState<NetInfoStateType.bluetooth>;

                                                          type NetInfoCellularState

                                                          type NetInfoCellularState = NetInfoConnectedState<
                                                          NetInfoStateType.cellular,
                                                          {
                                                          cellularGeneration: NetInfoCellularGeneration | null;
                                                          carrier: string | null;
                                                          }
                                                          >;

                                                            type NetInfoChangeHandler

                                                            type NetInfoChangeHandler = (state: NetInfoState) => void;

                                                              type NetInfoConnectedStates

                                                              type NetInfoConnectedStates =
                                                              | NetInfoCellularState
                                                              | NetInfoWifiState
                                                              | NetInfoBluetoothState
                                                              | NetInfoEthernetState
                                                              | NetInfoWimaxState
                                                              | NetInfoVpnState
                                                              | NetInfoOtherState;

                                                                type NetInfoDisconnectedStates

                                                                type NetInfoDisconnectedStates = NetInfoUnknownState | NetInfoNoConnectionState;

                                                                  type NetInfoEthernetState

                                                                  type NetInfoEthernetState = NetInfoConnectedState<
                                                                  NetInfoStateType.ethernet,
                                                                  {
                                                                  ipAddress: string | null;
                                                                  subnet: string | null;
                                                                  }
                                                                  >;

                                                                    type NetInfoNoConnectionState

                                                                    type NetInfoNoConnectionState = NetInfoDisconnectedState<NetInfoStateType.none>;

                                                                      type NetInfoOtherState

                                                                      type NetInfoOtherState = NetInfoConnectedState<NetInfoStateType.other>;

                                                                        type NetInfoState

                                                                        type NetInfoState = NetInfoDisconnectedStates | NetInfoConnectedStates;

                                                                          type NetInfoSubscription

                                                                          type NetInfoSubscription = () => void;

                                                                            type NetInfoVpnState

                                                                            type NetInfoVpnState = NetInfoConnectedState<NetInfoStateType.vpn>;

                                                                              type NetInfoWifiState

                                                                              type NetInfoWifiState = NetInfoConnectedState<
                                                                              NetInfoStateType.wifi,
                                                                              {
                                                                              ssid: string | null;
                                                                              bssid: string | null;
                                                                              strength: number | null;
                                                                              ipAddress: string | null;
                                                                              subnet: string | null;
                                                                              frequency: number | null;
                                                                              }
                                                                              >;

                                                                                type NetInfoWimaxState

                                                                                type NetInfoWimaxState = NetInfoConnectedState<NetInfoStateType.wimax>;

                                                                                  Package Files (2)

                                                                                  Dependencies (0)

                                                                                  No dependencies.

                                                                                  Dev Dependencies (40)

                                                                                  Peer Dependencies (1)

                                                                                  Badge

                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@react-native-community/netinfo.

                                                                                  • Markdown
                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@react-native-community/netinfo)
                                                                                  • HTML
                                                                                    <a href="https://www.jsdocs.io/package/@react-native-community/netinfo"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>