React-native: iOS: NetInfo.isConnected devuelve siempre falso

También puedo reproducir esto con RN 0.29.0. Estaba ejecutando 0.26.2 antes y funcionó bien con él. Voy a intentar compilar desde el código fuente y depurarlo.

+1

He informado del mismo problema antes: https://github.com/facebook/react-native/issues/8469

La solución rápida es agregar un controlador de eventos NetInfo.isConnected.addEventListener('change', Function.prototype)

+1 y el mismo problema con NetInfo.fetch (). Done () - siempre devuelve unknown

Lo resolví de esta manera:

componentDidMount() {
  const dispatchConnected = isConnected => this.props.dispatch(setIsConnected(isConnected));

  NetInfo.isConnected.fetch().then().done(() => {
    NetInfo.isConnected.addEventListener('change', dispatchConnected);
  });
}

+1

hemos encontrado este error en 0.29.2 ..

hemos encontrado este error en 0.28

0.30.0 todavía no funciona

El código relevante no ha cambiado, por lo que tiene sentido que todavía no funcione.

Tenga en cuenta que anteriormente informé el error aquí: https://github.com/facebook/react-native/issues/8469 donde detalla la causa y tiene un código de muestra adjunto. Por eso, creo que tiene sentido dejar esto cerrado.

El número de problemas de RN abiertos crece a diario, por lo que es importante hacer nuestra parte y consolidarnos donde sea posible.

Noté el mismo problema hoy

Estoy usando la versión 0.30.0, y también encontré este error.

el mismo problema para mí, estoy usando [email protected] y la recuperación siempre devuelve desconocido.

Pero podemos usar addEventListener en su lugar.

NetInfo.addEventListener('change',
    (networkType)=> {
        this.setState({networkType})
    }
)

en vez de:

NetInfo.fetch().done(
    (networkType)=> {
        this.setState({networkType})
    }
)

@ facebook-github-bot error

Tengo este problema en 0.31, ¿se solucionará?

igual a 0.32

@knowbody ¿Cómo funciona tu fragmento? ¿Necesito definir un método setIsConnected en mi clase o como una función global o algo más? Porque, en realidad tengo un error que decía Can't find variable: setIsConnected

@florentsorel, entonces en mi proyecto uso redux para la gestión estatal y setIsConnected es mi creador de acciones, que se parece a:

actions/network.js

export const setIsConnected = (isConnected) => ({
  type: 'SET_IS_CONNECTED',
  isConnected
});

y luego tengo un network reductor:

reducers/network.js

const initialState = {
  isConnected: true
};

const network = (state = initialState, action) => {
  switch (action.type) {
    case 'SET_IS_CONNECTED':
      return {
        isConnected: action.isConnected
      };

    default:
      return state;
  }
}

export default network;

+1

Tengo este problema en v0.34.1

Editar: actualizado a v0.35.0 y el mismo problema.

lo mismo en v0.35.0

Tengo el mismo problema en v0.36.0

@knowbody snippet me funciona en 0.36

@Dnld : @Ehesp dice que funciona en la v.036, ¿tú y otros 5 no? ¿No se resuelve esto eventualmente? También solía tener problemas con 0.33 y me gustaría actualizar. Gracias.

El código subyacente no ha cambiado realmente, así que me sorprendería si esto estuviera "arreglado".

Pongo la corrección entre comillas porque parece que la motivación de este cambio es configurar solo la maquinaria nativa que observa el estado de la red si el código de la aplicación está interesado en observarlo.

Las aplicaciones registran interés al agregar un detector de eventos que luego comienza a verificar la accesibilidad .

En este punto, parece que este es el comportamiento deseado, por lo que quizás se requiera un cambio de documentación. NetInfo.isConnected devuelve un valor booleano para que no exprese que el estado es desconocido y que eso no cambiará hasta que agregue un detector de eventos. Alternativamente, la función podría cambiarse para devolver null o un booleano.

Mis aplicaciones tienen un código muy similar al que publicó @knowbody . Sin embargo, no llamo NetInfo.isConnected.fetch() en absoluto, ya que es inútil al inicio.

Supongo que hay conectividad, agrego el oyente y luego el estado se actualizará cuando el estado de conectividad ya no sea desconocido.

0.34.1 todavía no funciona

Mismo problema con RN 0.37.0

@ xing-zheng, por alguna razón, su solución solo devuelve 'MÓVIL', incluso cuando apago el wifi en mi computadora, lo que debería reflejarse en mi emulador. ¿Alguna idea de por qué?

componentDidMount() { NetInfo.addEventListener('change', (networkType)=> { this.setState({connected: networkType}) } ) }

Mismo problema con RN 0.38.0

lo mismo en 0.39 también

Cuando pruebo la solución addEventListener, NetInfo solo detecta uno o dos cambios de conexión. Por ejemplo, si comienzo con una conexión y luego la desconecto, Netinfo lo detectará, pero si vuelvo a conectarlo, no detectará que ahora estoy conectado. NetInfo está produciendo una gran cantidad de falsos positivos en mi aplicación, incluso con la solución. ¿Alguien más está experimentando lo mismo?

Tuve que construir una solución extraña para resolver esto. Por alguna razón, un método funciona en Android y el otro en iOS. Una solución a esto sería genial.

function handleFirstConnectivityChange(isConnected) {
    if (!sConnected) {
     // do action
    } 
    NetInfo.isConnected.removeEventListener('change', handleFirstConnectivityChange);
}

if (Platform.OS === 'ios') {
    NetInfo.isConnected.addEventListener('change', handleFirstConnectivityChange); 
} else {
    NetInfo.isConnected.fetch().then(isConnected => {
    if (!sConnected) {
        // do action
    } 
}

@ robertodias180 no funciona.

RN- 0.39+

function handleFirstConnectivityChange (isConnected) {
if (! sConnected) {
// hacer acción
}
NetInfo.isConnected.removeEventListener ('cambio', handleFirstConnectivityChange);
}

if (Platform.OS === 'ios') {
NetInfo.isConnected.addEventListener ('cambio', handleFirstConnectivityChange);
} más {
NetInfo.isConnected.fetch (). Luego (isConnected => {
if (! sConnected) {
// hacer acción
}
}

¿Puedes ayudarme por favor?

@imbudhiraja ¿funciona en alguna de las plataformas?

No, no estaba funcionando en ninguna plataforma.

Gracias
Manish Budhiraja

El 3 de enero de 2017 a las 8:12 p.m., "Roberto Dias" [email protected] escribió:

@imbudhiraja https://github.com/imbudhiraja ¿ Funciona en alguno de los
plataformas?

-
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/facebook/react-native/issues/8615#issuecomment-270128504 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/AVTjXHSe8OcVq8fQ5XVk8hh9XXHfHFVZks5rOl5ggaJpZM4JGaBc
.

Parece que esto puede deberse a dos problemas:

1. isConnected.fetch parece estar roto en iOS; la solución debería ser sencilla. La solución alternativa publicada por @ robertodias180 tiene sentido porque consulta el código nativo con otro método.
2. La escasez de NetInfo descrita por @Aristekrat . Esto es más preocupante: ¿alguien puede ayudar a proporcionar una forma detallada de reproducir este problema? Entonces debería poder ayudar a arreglarlo.

RN 0.38.1 y versiones anteriores, iOS Simulator.

componentDidMount() {
    NetInfo.isConnected.fetch().then(this._handleConnectionInfoChange);
    NetInfo.isConnected.addEventListener(
        'change',
        this._handleConnectionInfoChange
    );
 }

 componentWillUnmount(){
     NetInfo.isConnected.removeEventListener(
        'change',
        this._handleConnectionInfoChange
    );
 }

_handleConnectionInfoChange(isConnected){
    this.props.connectActions.netInfo(isConnected);

    dbg('connected', isConnected);

};

El NetInfo.isConnected.fetch().then(this._handleConnectionInfoChange); inicial recupera correctamente el estado de conexión actual. Sin embargo, eventListener no captura los cambios posteriores en el estado de la conexión.

He tenido este problema para muchas versiones de RN ahora.

@imbudhiraja terminé cambiando el código por algo "más limpio". Tengo una utilidad que tiene el estado actual de la conexión de red. Esto está funcionando en ambas plataformas. I initializeConnection cuando se abre la aplicación y luego isConnected cuando lo necesito. Tenga en cuenta que puede tomar algo hasta que NetInfo obtenga el estado de conexión cuando se abra la aplicación (especialmente en Android). Acabo de hacer un retraso hasta hasConnection !== null . Espero eso ayude

const hasConnection = null;

export const initializeConnection = () => {

  const dispatchConnected = isConnected => { hasConnection = isConnected; };

  NetInfo.isConnected.fetch().then().done(() => {
    NetInfo.isConnected.addEventListener('change', dispatchConnected);
  });

}

export const isConnected = () => {
  NetInfo.fetch().done((reach) => {
    console.log('Initial: ' + reach);
  });
  return hasConnection;
}

Intenté algo similar, sigo encontrándome con la situación de que eventListener no lo detecta cuando la conexión regresa (en el simulador).

Recargar la aplicación sin conexión a Internet => Detectado
Vuelva a encender Internet => NO detectado

Recargar la aplicación con conexión a Internet => Detectado
Apagar Internet => Detectado
Vuelva a encender Internet => NO detectado

<strong i="11">@autobind</strong>
export default class ConnectionToast extends React.Component {

    constructor(props){
        super(props);
    }

    componentDidMount() {
        NetInfo.isConnected.fetch()
            .then(this._handleConnectionInfoChange)
            .done(this._addListener);
     }

     componentWillUnmount(){
         this._removeListener();
     }

     _addListener(){
         NetInfo.isConnected.addEventListener(
             'change',
             this._handleConnectionInfoChange
         );
     }

     _removeListener(){
         NetInfo.isConnected.removeEventListener(
            'change',
            this._handleConnectionInfoChange
        );
     }

    _handleConnectionInfoChange(isConnected){
        this.props.connectActions.netInfo(isConnected);

        dbg('connected', isConnected);

        // this._removeListener();
        // this._addListener();

    }

[...]

Intenté eliminar y volver a agregar al oyente con cada cambio, pero sin alegría.

@mschipperheyn Estoy experimentando exactamente el mismo problema utilizando el enfoque que @knowbody publicó anteriormente.

Los documentos también implican que solo manejaría el primer cambio a través de handleFirstConnectivityChange . ¿Es esto correcto o debería detectar todos los cambios posteriores?

Asegúrate de tener

establecido en su archivo de manifiesto de Android. Este me hizo tropezar.

Mismo problema con RN 0.41.0

en iOS, no agregar oyente y no registrar SCNetworkReachabilitySetCallback. seguramente no funciona. ¿Cuál es el propósito del diseño?

igual a 0.41.2

@djohnkirby En tu comentario falta el XML que creo que

La línea para agregarle AndroidManifest.xml es:

 <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

0.39.2: Mismo problema. El resultado de NetInfo fetch no solo es siempre false , sino que también detecta un cambio de estado de conexión rápidamente después de que se inicia la aplicación

0.42.0: Mismo problema. También describí mi problema aquí: https://stackoverflow.com/questions/42642034/check-for-internet-connection-returns-wrong-results
Estoy probando en iOS y macOS Sierra.

ACTUALIZACIÓN : Mi problema se debió a las pruebas en el simulador, en un dispositivo real, todo funciona. Respondido en el enlace anterior.

Tengo el mismo problema :(

NetInfo.isConnected.fetch().then((isConnected) => { console.log(isConnected); });
// always return false

En caso de que alguien quiera saber si la aplicación se está ejecutando en el simulador o no: http://stackoverflow.com/a/34732015/552669

No es un error. El módulo nativo RCTNetInfo es una subclase de RCTEventEmitter , por lo que debemos agregar un observador para activar el método startObserving .
En el proceso de inicio de su aplicación, agregue un observador arbitrario a NetInfo, luego puede llamar a la función fetch .

De acuerdo con las sugerencias de @ robertodias180, se me ocurrió el contenedor para isConnected,
Parece funcionar, pero me pregunto si funcionará en todos los casos.

export function isNetworkConnected() {
  if (Platform.OS === 'ios') {
    return new Promise(resolve => {
      const handleFirstConnectivityChangeIOS = isConnected => {
        NetInfo.isConnected.removeEventListener('change', handleFirstConnectivityChangeIOS);
        resolve(isConnected);
      };
      NetInfo.isConnected.addEventListener('change', handleFirstConnectivityChangeIOS);
    });
  }

  return NetInfo.isConnected.fetch();
}

Mismo problema. 0.40

Estoy experimentando el mismo problema

0.42.3 - Experimenté el mismo problema al ejecutar iOS tanto en el simulador como en un dispositivo real. El uso de la solución de @ Knight704 ha mitigado el problema.

Lo mismo en 0.42.3

lo mismo en 0.43.1

Viendo esto en 0.40

tener este problema también. Pude hacer que funcionara al azar y luego dejó de funcionar.

La solución de @ Knight704 funcionó al principio para mí, pero por alguna razón una vez que la llamo desde dentro de la segunda capa de un navegador en un modal, la función deja de funcionar (nunca se llama a handleFirstConnectivityChangeIOS), incluso después de cerrar el modal. Comportamiento muy extraño, no tengo idea de por qué esto no funciona o si hay algo más en mi base de código que no funciona bien con NetInfo.

¿Qué me estoy perdiendo?

    this.state = {
            isConnected: null,
     }
    componentDidMount() {
        console.log('first one ', this.state.isConnected)
        NetInfo.isConnected.addEventListener(
            'change',
            this._handleConnectivityChange
        );
        console.log('second ', this.state.isConnected)
        NetInfo.isConnected.fetch().done(
            (isConnected) => {this.setState({isConnected});}
        );
        console.log('third ', this.state.isConnected)
    }
    componentWillUnmount(){
        console.log('did it unmount ', this.state.isConnected)
        NetInfo.isConnected.removeEventListener(
            'change',
            this._handleConnectionInfoChange
        );
        console.log('it did unmount ', this.state.isConnected)
    }
    _handleConnectivityChange = (isConnected) => {
        this.setState({
            isConnected,
        });
    };
   render() {
      console.log('fourth ', this.state.isConnected)
        if(this.state.isConnected === false){
            const connectAlert = (Alert.alert(
                'ERROR',
                'No connection bro!',
                [
                    {text: 'OK'},
                ]
            ))
        }
        return ()
}

así que cuando lo ejecuto, a veces me alerta, no siempre ...

Estos son los registros de la consola que regresan cuando me alerta incluso cuando hay conexión:

'fourth ', null
'first one ', null
'second ', null
'third ', null
'fourth ', false
'fourth ', true

Experimentando el mismo problema que @SteffeyDev cuando uso la solución de @ Knight704 en https://github.com/facebook/react-native/issues/8615#issuecomment -287977178 En la mayoría de los casos, esto funciona bien, sin embargo, cuando tengo modales empujados o desplegados, el mismo código nunca se resolverá, ya que supongo que el evento change ya se emitió.

Noté que bajo estas condiciones, NetInfo.fetch() devolvería un estado unknown (esto activará un false debajo de NetInfo.isConnected.fetch() y así pude solucionarlo con la siguiente modificación a la solución original:

export function isNetworkConnected() {
  return NetInfo.fetch().then(reachability => {
    if (reachability === 'unknown') {
      return new Promise(resolve => {
        const handleFirstConnectivityChangeIOS = isConnected => {
          NetInfo.isConnected.removeEventListener('change', handleFirstConnectivityChangeIOS);
          resolve(isConnected);
        };
        NetInfo.isConnected.addEventListener('change', handleFirstConnectivityChangeIOS);
      });
    }
    reachability = reachability.toLowerCase();
    return (reachability !== 'none' && reachability !== 'unknown');
  });
}

La condición unknown solo se activa en iOS ya que Android devuelve UNKNOWN . Esta es también la razón para poner en minúsculas antes de devolver el estado, ya que esto debería retener más o menos el comportamiento existente de NetInfo.isConnected.fetch .

lo mismo en 0.44

Al principio, observé que NetInfo solo quiere devolver el cambio de estado de la red después de un ciclo (encendido -> apagado). Resultó que solo tiene ese problema en el simulador. En un dispositivo real, dispara la devolución de llamada correctamente incluso para múltiples ciclos de conexión / desconexión.

Código de muestra

  NetInfo.addEventListener( 'change', this._onConnectivityChange );

  _onConnectivityChange(connType) {
    // Do something with connType...
  }

Este problema me molestó por un tiempo e indirectamente terminé creando una pequeña biblioteca de utilidades enfocada en la detección de RN fuera de línea / en línea, que abarca patrones típicos de React y una buena integración con redux.

Funciona correctamente en dispositivos reales, tanto Android como iOS. Sin embargo, también puedo corroborar que a veces el oyente no se activa en el simulador de iOS y el estado de conectividad se vuelve inconsistente. Todavía no he probado las soluciones propuestas por @ knight704 y @Ignigena ( aquí y aquí respectivamente) pero probablemente las probaré pronto cuando tenga tiempo.

¡Un PR también es muy bienvenido en caso de que más personas confirmen que esas soluciones funcionan como un encanto!

Por favor, arregla.

Si es poco probable que esto se solucione pronto, ¿podemos al menos actualizar los documentos para indicar que esto no funciona en iOS?

@ jpb12 quizás valga la pena hacer el PR y ver si lo fusionan. De hecho, puede hacer que esto sea más visible, ya que parece que se ha olvidado.

Estoy enfrentando este problema en la versión de Android. Parece estar relacionado con pasar al fondo y volver al primer plano. Desafortunadamente, no puedo reproducir este problema de manera confiable, pero definitivamente sucede después de varias transiciones de fondo / primer plano. Especialmente si el estado de la conexión se ha cambiado esa vez

Cuando sucede
NetInfo.isConnected.fetch().then(isConnected => {...}) siempre devuelve false
NetInfo.fetch().then((reach) => {...}) siempre devuelve NONE
agregar / eliminar oyentes no ayuda

Estaría muy agradecido por cualquier forma confiable de detectar el estado real de la conexión.

Estoy enfrentando un comportamiento extraño porque isConnected devuelve verdadero cuando se conecta a wifi (hasta ahora está bien) pero si el módem no llega a Internet, isConnected sigue siendo verdadero. No estoy realmente seguro de cómo verificar de manera efectiva la conexión a Internet, no solo la conexión de red. ¿Algunas ideas? Gracias

@kodatech Este módulo debería ayudarlo a resolver ese problema. Lo he usado recientemente en un proyecto y lo recomiendo encarecidamente https://github.com/rauliyohmc/react-native-offline

Muchas gracias @craigcoles

@ Knight704 gracias hermano.

@craigcoles ¿Tienes algún código de trabajo que pueda seguir?

@nmfzone No tengo nada que pueda mostrarte, pero hay muchos ejemplos de código en el archivo Léame 😃

Estoy usando los eventos de escucha de Netinfo de la siguiente manera, funciona muy bien en ambas plataformas.
"react-native": "0.43.4",

componentDidMount(){
        NetInfo.isConnected.addEventListener('change', this._handleConnectivityChange);

    }

    componentWillUnmount(){
        NetInfo.isConnected.removeEventListener('change', this._handleConnectivityChange);
    }

    _handleConnectivityChange = (isConnected) => {
         console.warn(isConnected);
    }

@ sumesh1993 Según mi experiencia, si la aplicación de Android se ha minimizado (en segundo plano), no reacciona en el evento 'change' . Probado en mi Galaxy Note 5, Android 7.0

El módulo https://github.com/rauliyohmc/react-native-offline que se recomendó anteriormente solo hace ping continuamente https://google.com . Funciona pero preferiría arreglar este error

Eso tiene sentido ya que las aplicaciones de Android se suspenden mientras están en segundo plano. Para recibir eventos, debe crear un servicio que continuará ejecutándose incluso mientras la aplicación esté suspendida.

Alternativamente, puede agregar un controlador onResume a la aplicación y luego consultar el estado sin conexión. Eso debería ser más simple que crear y administrar un servicio.

@ alsh76 para mí está funcionando cuando la aplicación está en segundo plano, no funciona cuando la aplicación se elimina del menú multitarea.
Lo resolví llamando a la siguiente función cada vez que se inicia mi pantalla de inicio.
if(Platform.OS === 'android'){ NetInfo.isConnected.fetch().then(isConnected => { if(!isConnected) return; //Do something }); }

Encontré el mismo problema con el dispositivo virtual Android. Pero la cosa es que estuvo bien hace unos días y todavía lo hace en el dispositivo y emulador iOS. ¿Alguien encontró una forma estable y correcta de obtener el estado de la conexión de red?

¡Gracias @ sumesh1993 que me hizo el truco en iOS!
@igorarkhipenko, ¿

Hola, ¿agregaste permiso, por ejemplo, Android necesita agregar?
AndroidManifest.xml
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

solo una pequeña actualización de las soluciones de @ Knight704 y @Ignigena, ya que NetInfo.fetch está obsoleto ahora. Esto funcionó para mí:
''
const isNetworkConnected = () => {
return NetInfo.getConnectionInfo (). luego (alcanzabilidad => {
if (reachability.type === 'unknown') {
devolver nueva promesa (resolver => {
const handleFirstConnectivityChangeIOS = isConnected => {
NetInfo.isConnected.removeEventListener ('connectionChange', handleFirstConnectivityChangeIOS);
resolver (está conectado);
};
NetInfo.isConnected.addEventListener ('connectionChange', handleFirstConnectivityChangeIOS);
});
}
return (reachability.type! == 'none' && reachability.type! == 'unknown')
});
}

¡Imho NetInfo.isConnected.fetch() es una característica importante y debería arreglarse lo antes posible!

@javache @sahrens @davidaurelio @janicduplessis @hramos @shergin @rigdern ¿hay alguna línea de tiempo para esto?

¡Gracias!

@pensierinmusica Este es un proyecto impulsado por la comunidad, así que me encantaría conseguir buenas relaciones públicas.

@shergin Pensé que React Native fue creado, mantenido y utilizado internamente por Facebook, y lanzado bajo una licencia BSD de 3 cláusulas por este motivo. Así que asumí que el personal de Facebook arreglaría errores, especialmente los importantes. De todos modos, es bueno saber que los RP son bienvenidos.

cc @rigdern

La comunidad escribe y mantiene gran parte del código central de RN.

Y hay muchas características y funcionalidades que Facebook no usa, por lo que es difícil para nosotros priorizarlas y preferir las relaciones públicas de la comunidad donde el autor puede verificar la solución para su error / caso de uso.

También estoy teniendo problemas en reaccionar 0.47.0 con ios.

@pensierinmusica definitivamente debería priorizarse este tema. ¿Qué tan difícil puede ser tener un retorno booleano de .isConnected ()?

Muy bien, aquí hay una solución alternativa que debería funcionar (bueno, lo hace para mí). Envío una solicitud http a un sitio que sé que estará activo y evalúo la respuesta.

He inicializado un repositorio que debería funcionar de inmediato. https://github.com/JamesDorrian/NetInfoCheckConnection/tree/master

Nota: asegúrese de cambiar la variable httpAddress de https://www.galwaydaily.com a otra (tal vez google.com) ya que no puedo garantizar que siempre estará activa. ¡Espero que esto ayude a cualquiera que se sienta frustrado por NetInfo!

@pensierinmusica @anujsinghwd

@JamesDorrian gracias, terminé haciendo algo similar, haciendo ping a "google.com".

Aquí está el fragmento:

// /utilities/connectivity.js

import { Alert } from 'react-native';

export function warning () {
  Alert.alert(
    'No connection',
    'Mmm... you seem to be offline'
  );
};

export async function checkAsync () {
  try {
    const res = await fetch('https://google.com');
    if (res.status === 200) return true;
  } catch (e) {
    warning();
  }
  return false;
};

Aún así, esto es solo una solución temporal, y creo que NetInfo.isConnected debería arreglarse lo antes posible.

let isConnected = false;

Platform.OS === "ios" 
  ? (isConnected = await fetch("https://www.google.com"))
  : (isConnected = await NetInfo.isConnected.fetch());

Platform.OS === "ios" && (isConnected.status = 200)
  ? (isConnected = true)
  : (isConnected = false);

console.log(isConnected); //Result

¿Podemos detenernos con los +1 comentarios sobre este tema, para esto se utilizan las reacciones?

ios:
primera solicitud. si el servidor falla, el teléfono tiene wifi.
NetInfo.isConnected.fetch (). Luego ((isConnected) => {siempre falso}
0.49.3.

@kddc, su solución parece funcionar bien en desarrollo 👍

Simplemente agregue la Biblioteca de accesibilidad a su proyecto XCode de Apple que sirvió aquí , es la solución.

@fuatsengul He agregado el proyecto de accesibilidad como una biblioteca en mi proyecto de Xcode, pero aún así el problema no está resuelto, ¿podría informarme qué más se debe hacer para resolver el problema? Gracias.

El problema parece ser solo con la api de recuperación ... sin embargo, agregar un detector de eventos está funcionando en iOS .. Sin embargo, addEventListener no funciona en Android, por lo que debe usar la api de búsqueda :)

Aquí está mi fragmento para que funcione en ambos mundos:

function handleFirstConnectivityChange(isConnected) {
  console.log('Then, is ' + (isConnected ? 'online' : 'offline'))
  NetInfo.isConnected.removeEventListener(
    'connectionChange',
    handleFirstConnectivityChange,
  )
}

if (Platform.OS === 'android') {
    NetInfo.isConnected.fetch().then(isConnected => {
      console.log('First, is ' + (isConnected ? 'online' : 'offline'))
    })
  } else {
    NetInfo.isConnected.addEventListener(
      'connectionChange',
      handleFirstConnectivityChange,
    )
  }

Se muestra sin conexión en IOS a pesar de que está conectado
Enfermera - 0.50

NetInfo.isConnected.fetch().then(isConnected => { console.log('First, is ' + (isConnected ? 'online' : 'offline')); });

@kddc gracias por la solución.
Tengo un problema con él en mi dispositivo iOS y el escenario es el siguiente:

1. ios -> el modo avión está activado
2. realizar búsqueda -> obteniendo 'error de red', isConnected es falso y reachability.type es ninguno
3. ios -> el modo avión está desactivado
4. realizar búsqueda -> obteniendo 'error de red', isConnected es falso y reachability.type es ninguno

Todo el tiempo que se ejecuta la aplicación, en segundo plano mientras se cambia el modo avión.
Solo reiniciar la aplicación "captura" la nueva conexión de red.

+1

+1

Gracias por la corrección @ alburdette619
Entonces, esto está arreglado, ¿estará disponible en la versión 0.54?

@ assafb81 No estoy seguro, aparentemente lo están aterrizando internamente y no estoy seguro de cuál es el proceso para eso, ¿verdad?

Cuando su solicitud de extracción se fusiona, Facebook primero la incorpora en su repositorio interno de React Native y ejecuta pruebas adicionales entre otras cosas. Cuando tiene éxito, el cambio se exporta de nuevo al repositorio de GitHub.

Al observar la actividad de su solicitud de extracción, puede ver que su confirmación ahora está fusionada en GitHub . Al mirar la información de confirmación, puede ver en qué ramas está incluido. Actualmente, solo está en la rama "maestra":

A modo de comparación, si observa una confirmación anterior , puede ver que aparece en varias ramas:

Al comienzo de cada mes, se crea una nueva rama candidata a versión basada en "master". Por lo tanto, es probable que su cambio se encuentre en la próxima versión candidata a principios de marzo. Puede leer más sobre el calendario de lanzamiento de React Native en esta publicación de blog .

Adam Comella
Microsoft Corp.

¿Alguien verificó este problema con la última RN 54? Para mí, siempre vuelve 'verdadero' ahora en iOS y en Android funciona perfectamente bien. Alguien más ve este problema ?

0.53 siempre falso .. @deepaksasken .. parece que necesito deshabilitar el código solo para Android .. No se puede usar 0.54 para muchos errores.

@ alien3d ¿ Te refieres a deshabilitarlo para iOS y mantenerlo solo para Android? ¿En Android funciona?

@afilp solo sigo el ejemplo anterior para ios

    if (Platform.OS === "ios") {
            isConnected = await fetch("https://www.google.com");
            if (isConnected) { }
  } else { 
    NetInfo.isConnected.fetch().done(
                (isConnected) => {
                    if (isConnected) { }
} 

Todavía necesito muchas pruebas antes de considerarlo estable. ahora usando de nuevo 0.530

@ assafb81 ¿Encontraste una solución para el problema con el modo avión? Estoy usando su solución en 0.53.

@aflip Cuando los datos están habilitados pero aún no hay ningún paquete, devuelve isConnected verdadero. ¿Has intentado resolverlo?

¿Por qué hay un error removeEventListener. ¿No debería la aplicación estar escuchando los cambios de red en todo momento? ¿Nadie?

También tiene el mismo problema que los usuarios anteriores. Los oyentes de eventos de NetInfo parecen ser muy poco fiables. He probado muchas de las soluciones anteriores sin resultados estables. Por ahora, confiaré en obtener https://google.com o un punto final de salud en mis propios servidores para asegurar que mis usuarios tengan una conexión a Internet.

@MichaelPintos A mí me funciona, gracias.

RN 0.54.2
SO: iOS
mismo problema, siempre desconocido

Cuando actualizo RN a 0.55.3

Estoy usando este código, primero devuelvo desconocido, y luego funciona

    NetInfo.getConnectionInfo()
        .then()
        .done(() => {
                switch (connectionInfo.type) {
                    case 'none':
                        Alert.alert('aa', 'none');
                        break;
                    case 'wifi':
                        Alert.alert('aa', 'wifi');
                        break;
                    case 'cellular':
                        if (connectionInfo.effectiveType !== 'unknown') {
                            Alert.alert('aa', `cellular ${connectionInfo.effectiveType}`);
                        } else {
                            Alert.alert('aa', 'cellular unknown');
                        }
                        break;
                    case 'unknown':
                        Alert.alert('aa', 'unknown');
                        break;
                    default:
                        Alert.alert('aa', 'default');
                        break;
                }
            });
        });

Bien, hagamos un pequeño truco.

    NetInfo.getConnectionInfo()
        .then()
        .done(() => {
            NetInfo.getConnectionInfo().then(connectionInfo => {
                switch (connectionInfo.type) {
                    case 'none':
                        Alert.alert('aa', 'none');
                        break;
                    case 'wifi':
                        Alert.alert('aa', 'wifi');
                        break;
                    case 'cellular':
                        if (connectionInfo.effectiveType !== 'unknown') {
                            Alert.alert('aa', `cellular ${connectionInfo.effectiveType}`);
                        } else {
                            Alert.alert('aa', 'cellular unknown');
                        }
                        break;
                    case 'unknown':
                        Alert.alert('aa', 'unknown');
                        break;
                    default:
                        Alert.alert('aa', 'default');
                        break;
                }
            });
        });

Esta es mi solución. Espere una solución oficial.

Se actualizó a 55 específicamente porque el registro de cambios decía que se suponía que debía solucionar este problema; aún no funciona (0.55.3).

Puedo hacerlo funcionar usando una solución similar a @ yuyao110120 :

NetInfo.isConnected.fetch().then(() => {
  NetInfo.isConnected.fetch().then(isConnected =>
    // isConnected is now the correct value
  });
});

Ya no confío en NetInfo (react-native 0.53.3)
Esto es lo que hago para asegurarme de que haya Internet:

async function handleConnectivityChange(status) {
  const { type } = status;
  let probablyHasInternet;
  try {
    const googleCall = await fetch(
        'https://google.com', {
        headers: {
          'Cache-Control': 'no-cache, no-store, must-revalidate',
          Pragma: 'no-cache',
          Expires: 0,
        },
      });
    probablyHasInternet = googleCall.status === 200;
  } catch (e) {
    probablyHasInternet = false;
  }

  console.log(`@@ isConnected: ${probablyHasInternet}`);

}

  NetInfo.getConnectionInfo().then(handleConnectivityChange);
  NetInfo.addEventListener('connectionChange', handleConnectivityChange);

@SudoPlz Hice lo mismo en mis aplicaciones, funciona bien. ¡Pero la API NetInfo definitivamente debería arreglarse jaja!

@SudoPlz Me di cuenta de que fetch almacena en caché la solicitud en Android. Tendrías que darle algunos encabezados para evitar eso.

      const googleRequest = await fetch('https://www.google.com', {
        headers: {
          'Cache-Control': 'no-cache, no-store, must-revalidate',
          'Pragma': 'no-cache',
          'Expires': 0
        }
      });

Ok, gracias por avisarme @AbdallaMohamed actualicé el comentario.

Igual que @kylevdr , funcionó de manera confiable, pero agregar un pequeño tiempo de espera antes de la segunda llamada parece ayudar con el parpadeo, donde se desconectará por una fracción de segundo justo después de desbloquear

Editar: fwiw esto funciona en 55.3, pero no 55.4

Agregar un detector de eventos de conexión inicial hará que NetInfo.getConnectionInfo() y NetInfo.isConnected.fetch() funcionen correctamente en la primera llamada.

const onInitialNetConnection = isConnected => {
    console.log(`Is initially connected: ${isConnected}`);

    NetInfo.isConnected.removeEventListener(
        onInitialNetConnection
    );
};

NetInfo.isConnected.addEventListener(
    'connectionChange',
    onInitialNetConnection
);

// both now work on the first call.
await NetInfo.getConnectionInfo();
await NetInfo.isConnected.fetch();

Gracias # 8469

Asegúrese de importar este archivo o no se ejecutará.

PD Si está usando fetch , use method: 'HEAD' para reducir la cantidad de datos transmitidos.

Ninguna de las soluciones anteriores funcionó al ejecutar la aplicación en modo de depuración en un iPhone 8 (React Native 0.55.3, iOS 11.3.1) en el siguiente escenario: Cierre la aplicación e iníciela con datos móviles y wifi desactivados.

Cualquier evento posterior se pierde con todas las soluciones mencionadas anteriormente (excepto la respuesta de @SudoPlz ). Solo ejecutar la aplicación en modo de lanzamiento en el dispositivo o en modo de depuración en un simulador desencadenó eventos NetInfo .

@nlindroos , ¿confirmas realmente que NetInfo funciona bien en dispositivos que ejecutan la versión de lanzamiento?

En el caso específico de _iniciar_ la aplicación en modo fuera de línea en un dispositivo iOS físico, ejecutar en modo de lanzamiento fue la única solución funcional para activar cualquier evento NetInfo . No he probado todos los escenarios relacionados lo suficiente como para dar fe de esto como una solución genérica a todos los problemas de NetInfo .

Puedo decir que la combinación de las soluciones que @woodpav y @AbdallaMohamed funcionaron para mí
Estoy usando RN versión 0.55.4

Debo hacer ping al servidor de Google con frecuencia para verificar la conexión a Internet 😕

Estoy usando el simulador de iPhone 8 - 11.3 y en la versión RN 0.55.4 NetInfo.isConnected.fetch (). Luego (isConnected => console.log ('isConnected', isConnected))
Siempre devuelve falso. Este también es un problema en la producción del teléfono. Probé variaciones de datos móviles y wifi.

Al volver a la versión 0.55.3 de RN, parece que vuelve a funcionar.

@octopitus , @martinentelect
este es mi código, estoy usando la versión nativa de react 0.55.4, y es una solución sensata y funcional hasta que se solucione NetInfo .
En mi archivo api.js tengo este código

import { NetInfo } from 'react-native';
import { url } from '[AppName]/src/config';

export const onInitialNetConnection = () => {
    NetInfo.isConnected.removeEventListener(onInitialNetConnection);
};

const getDataById = async (dataId) => {
    // both now work on the first call.
    await NetInfo.getConnectionInfo();
    const isConnected = await NetInfo.isConnected.fetch();
    if (!isConnected) {
        throw new Error('networkError');
    }
    const response = await fetch(`${url}${dataId}`, {
        headers: {
            'Cache-Control': 'no-cache, no-store, must-revalidate',
            Pragma: 'no-cache',
            Expires: 0,
        },
    });
    if (response.ok) {
        return response.json();
    }
    throw new Error('invalidCode');
};

export default getDataById;

En mi archivo App.js (mi punto de entrada a la aplicación) agrego el detector de eventos:

NetInfo.isConnected.addEventListener(
            'connectionChange',
            onInitialNetConnection,
        );

@ assafb81 ¡ Gracias! Esto ayudó a mi caso de uso.

En mi caso, el detector de eventos funciona perfectamente en iOS, pero no en Android (al menos en el emulador).
¿Existen soluciones alternativas para los oyentes en Android mientras siguen usando NetInfo?

    NetInfo.isConnected.addEventListener(
      "connectionChange",
      this.handleConnectionChange
    ); 

Utilizar

this.count = 0
handleConnectivityChange(isConnected) {
   //for iOS
    this.count++
  console.log(isConnected + "isConnected")
  if(this.count > 1){
    console.log(isConnected + "this is the right value")
  }

@tannera ,
comprobar el dispositivo Android real y no el emulador

En 0.55.4 esto sigue siendo un error, y acabo de recibir un golpe en la producción 😢

Todavía no fijo en 0.56

@SudoPlz He ocultado su comentario en el hilo de discusión 0.57 como fuera de tema. Como sabe, hay cientos de problemas abiertos en el repositorio, pero ese hilo se centra en obtener una versión 0.57.

Este hilo cerrado es prácticamente invisible para los mantenedores, y me sorprende que seis meses después de que aterrizara una posible solución, nadie haya abierto un nuevo problema. Si esto es algo que le gustaría ver corregido en el maestro, abra un nuevo número con detalles e, idealmente, envíe un PR.

Aquí hay un ejemplo mínimo reproducible (probado en un dispositivo iOS), con un código de @woodpav compartido arriba para solucionar el problema comentado en la parte superior: https://snack.expo.io/@notbrent/netinfo -repro.