Comprueba si hay una conexión a Internet disponible en la aplicación Flutter

Hola usuario de nuestra página web, hemos encontrado la solución a lo que buscabas, desplázate y la obtendrás aquí.

Solución:

El complemento de conectividad indica en sus documentos que solo proporciona información si hay una conexión de red, pero no si la red está conectada a Internet.

Tenga en cuenta que en Android, esto no garantiza la conexión a Internet. Por ejemplo, la aplicación puede tener acceso wifi, pero puede ser una VPN o la wifi de un hotel sin acceso.

Puedes usar

import 'dart:io';
...
try 
  final result = await InternetAddress.lookup('google.com');
  if (result.isNotEmpty && result[0].rawAddress.isNotEmpty) 
    print('connected');
  
 on SocketException catch (_) 
  print('not connected');

Para cualquier otra persona que aterrice aquí, me gustaría agregar a la respuesta de Günter Zöchbauer: esta fue mi solución para implementar una utilidad para saber si hay Internet o no, independientemente de cualquier otra cosa.

Descargo de responsabilidad:

Soy nuevo en Dart y Flutter, por lo que puede que este no sea el mejor enfoque, pero me encantaría recibir comentarios.

---

Combinando flutter_connectivity y la prueba de conexión de Günter Zöchbauer

Mis requisitos

No quería tener un montón de código repetido en cualquier lugar donde necesitaba verificar la conexión y quería que actualizara automáticamente los componentes o cualquier otra cosa que se preocupara por la conexión cada vez que hubiera un cambio.

ConnectionStatusSingleton

Primero configuramos un Singleton. Si no está familiarizado con este patrón, hay mucha buena información en línea sobre ellos. Pero la esencia es que desea crear una única instancia de una clase durante el ciclo de vida de la aplicación y poder usarla en cualquier lugar.

Este singleton se engancha en flutter_connectivity y escucha los cambios de conectividad, luego prueba la conexión de red, luego usa un StreamController para actualizar todo lo que le importa.

Se parece a esto:

import 'dart:io'; //InternetAddress utility
import 'dart:async'; //For StreamController/Stream

import 'package:connectivity/connectivity.dart';

class ConnectionStatusSingleton 
    //This creates the single instance by calling the `_internal` constructor specified below
    static final ConnectionStatusSingleton _singleton = new ConnectionStatusSingleton._internal();
    ConnectionStatusSingleton._internal();

    //This is what's used to retrieve the instance through the app
    static ConnectionStatusSingleton getInstance() => _singleton;

    //This tracks the current connection status
    bool hasConnection = false;

    //This is how we'll allow subscribing to connection changes
    StreamController connectionChangeController = new StreamController.broadcast();

    //flutter_connectivity
    final Connectivity _connectivity = Connectivity();

    //Hook into flutter_connectivity's Stream to listen for changes
    //And check the connection status out of the gate
    void initialize() 
        _connectivity.onConnectivityChanged.listen(_connectionChange);
        checkConnection();
    

    Stream get connectionChange => connectionChangeController.stream;

    //A clean up method to close our StreamController
    //   Because this is meant to exist through the entire application life cycle this isn't
    //   really an issue
    void dispose() 
        connectionChangeController.close();
    

    //flutter_connectivity's listener
    void _connectionChange(ConnectivityResult result) 
        checkConnection();
    

    //The test to actually see if there is a connection
    Future checkConnection() async 
        bool previousConnection = hasConnection;

        try 
            final result = await InternetAddress.lookup('google.com');
            if (result.isNotEmpty && result[0].rawAddress.isNotEmpty) 
                hasConnection = true;
             else 
                hasConnection = false;
            
         on SocketException catch(_) 
            hasConnection = false;
        

        //The connection status changed send out an update to all listeners
        if (previousConnection != hasConnection) 
            connectionChangeController.add(hasConnection);
        

        return hasConnection;
    

Uso

Inicialización

Primero tenemos que asegurarnos de llamar a la inicialización de nuestro singleton. Pero solo una vez. Esto depende de ti, pero lo hice en mi aplicación. main():

void main() 
    ConnectionStatusSingleton connectionStatus = ConnectionStatusSingleton.getInstance();
    connectionStatus.initialize();

    runApp(MyApp());

    //Call this if initialization is occuring in a scope that will end during app lifecycle
    //connectionStatus.dispose();   

En Widget o en otro lugar

import 'dart:async'; //For StreamSubscription

...

class MyWidgetState extends State 
    StreamSubscription _connectionChangeStream;

    bool isOffline = false;

    @override
    initState() 
        super.initState();

        ConnectionStatusSingleton connectionStatus = ConnectionStatusSingleton.getInstance();
        _connectionChangeStream = connectionStatus.connectionChange.listen(connectionChanged);
    

    void connectionChanged(dynamic hasConnection) 
        setState(() 
            isOffline = !hasConnection;
        );
    

    @override
    Widget build(BuildContext ctxt) 
        ...
    

¡Espero que alguien más encuentre esto útil!

---

Ejemplo de repositorio de github: https://github.com/dennmat/flutter-connectiontest-example

Alternar el modo avión en el emulador para ver el resultado

Ejemplo completo que demuestra a un oyente de la conectividad a Internet y su fuente.

Crédito a: conectividad y Günter Zöchbauer

import 'dart:async';
import 'dart:io';
import 'package:connectivity/connectivity.dart';
import 'package:flutter/material.dart';

void main() => runApp(MaterialApp(home: HomePage()));

class HomePage extends StatefulWidget 
  @override
  _HomePageState createState() => _HomePageState();


class _HomePageState extends State 
  Map _source = ConnectivityResult.none: false;
  MyConnectivity _connectivity = MyConnectivity.instance;

  @override
  void initState() 
    super.initState();
    _connectivity.initialise();
    _connectivity.myStream.listen((source) 
      setState(() => _source = source);
    );
  

  @override
  Widget build(BuildContext context) 
    String string;
    switch (_source.keys.toList()[0]) 
      case ConnectivityResult.none:
        string = "Offline";
        break;
      case ConnectivityResult.mobile:
        string = "Mobile: Online";
        break;
      case ConnectivityResult.wifi:
        string = "WiFi: Online";
    

    return Scaffold(
      appBar: AppBar(title: Text("Internet")),
      body: Center(child: Text("$string", style: TextStyle(fontSize: 36))),
    );
  

  @override
  void dispose() 
    _connectivity.disposeStream();
    super.dispose();
  


class MyConnectivity 
  MyConnectivity._internal();

  static final MyConnectivity _instance = MyConnectivity._internal();

  static MyConnectivity get instance => _instance;

  Connectivity connectivity = Connectivity();

  StreamController controller = StreamController.broadcast();

  Stream get myStream => controller.stream;

  void initialise() async 
    ConnectivityResult result = await connectivity.checkConnectivity();
    _checkStatus(result);
    connectivity.onConnectivityChanged.listen((result) 
      _checkStatus(result);
    );
  

  void _checkStatus(ConnectivityResult result) async 
    bool isOnline = false;
    try 
      final result = await InternetAddress.lookup('example.com');
      if (result.isNotEmpty && result[0].rawAddress.isNotEmpty) 
        isOnline = true;
       else
        isOnline = false;
     on SocketException catch (_) 
      isOnline = false;
    
    controller.sink.add(result: isOnline);
  

  void disposeStream() => controller.close();

Puntuaciones y reseñas

Si estás de acuerdo, tienes la opción de dejar una división acerca de qué te ha gustado de esta reseña.

---

---

Utiliza Nuestro Buscador