Dart 如何持续检查互联网连接与否？

我用这个代码检查互联网。我也将这个函数包装到initState中。当互联网不可用时，快餐店总是显示。但连接到互联网后，小吃店并没有消失。我不能使用连接插件，因为他们说在Android上，该插件不能保证连接到互联网

 checking1(TextEditingController usernameController, BuildContext context,
      String _url, GlobalKey<ScaffoldState> _scaffoldKey) async {
    try {
      final result = await InternetAddress.lookup('google.com');
      if (result.isNotEmpty && result[0].rawAddress.isNotEmpty) {
        usernameController.text == '' ?
        showDialog(...some code...) :
        usernameValidation(usernameController.text, context, _url);
      }
    }
    on SocketException
    catch (_) {
      _showSnackBar(_scaffoldKey);
    }
  }

checking1（TextEditingController用户名控制器、BuildContext上下文、，
字符串_url，GlobalKey _scaffoldKey）异步{
试一试{
最终结果=等待InternetAddress.lookup（'google.com'）；
if（result.isNotEmpty&&result[0].rawAddress.isNotEmpty）{
usernameController.text==''？
showDialog（…某些代码…）：
usernameValidation（usernameController.text、上下文、_url）；
}
}
论SocketException
接住{
_showSnackBar（_scaffoldKey）；
}
}

软件包将满足您的要求。它有一个

onConnectivityChanged

流，您可以订阅该流。这将在连接状态更改时通知您的应用程序。但仅仅因为你的设备连接到网络并不意味着它可以访问你的服务器并被连接。因此，在更新应用程序的内部状态之前，最好先进行DNS查找

---

另一个选择也可以是这个软件包：处理这个问题非常简单

首先需要导入包“package:flatter_offline/flatter_offline.dart”

之后，在小部件构建（BuildContext上下文）中包含OfflineBuilder，它将连续读取ConnectionyResult中的所有流更改

就像链接上的例子或者下面的例子一样

      @override
  Widget build(BuildContext context) {
    return OfflineBuilder(

        debounceDuration: Duration.zero,
        connectivityBuilder: (
            BuildContext context,
            ConnectivityResult connectivity,
            Widget child,
            ) {
          if (connectivity == ConnectivityResult.none) {

            return Scaffold(
              appBar: AppBar(
                title: const Text('Home'),
              ),
              body: Center(child: Text('Please check your internet connection!')),
            );
          }
          return child;
        },


        child: Scaffold(
          resizeToAvoidBottomPadding: false,
          appBar: AppBar(
              title: Text("Home")
          ),
          body: new Column(
            children: <Widget>[
              new Container(
                decoration: new BoxDecoration(color: Theme.of(context).cardColor),
                child: _buildTxtSearchBox(),
              ),
              new Divider(height: 10.0),
              new FloatingActionButton.extended(
                icon: Icon(Icons.camera_alt),
              ),
              new Container(
              ... 
              ),
            ],
          ),
          floatingActionButtonLocation: FloatingActionButtonLocation.centerFloat,
          drawer: MenuDrawer(),
        )
    );
  }

@覆盖
小部件构建（构建上下文）{
返回脱机生成器(
去Bounceduration:Duration.zero，
connectivityBuilder：(
构建上下文上下文，
连接性结果连接性，
孩子，
) {
if（连接性==ConnectivityResult.none）{
返回脚手架(
appBar:appBar(
标题：常量文本（“主页”），
),
body:Center（child:Text（'请检查您的互联网连接！'）），
);
}
返回儿童；
},
孩子：脚手架(
resizeToAvoidBottomPadding:false，
appBar:appBar(
标题：文本（“主页”）
),
正文：新栏目(
儿童：[
新容器(
装饰：新盒子装饰（颜色：主题.of（上下文）.cardColor），
子项：_buildTxtSearchBox（），
),
新隔板（高度：10.0），
新FloatingActionButton.extended(
图标：图标（Icons.camera\u alt），
),
新容器(
... 
),
],
),
浮动ActionButtonLocation:浮动ActionButtonLocation.centerFloat，
抽屉：MenuDrawer（），
)
);
}

演示internet连接及其源的侦听器的完整示例

导入'dart:async'；
导入“dart:io”；
导入“package:connectivity/connectivity.dart”；
进口“包装：颤振/材料.省道”；
void main（）=>runApp（MaterialApp（home:HomePage（））；
类主页扩展了StatefulWidget{
@凌驾
_HomePageState createState（）=>\u HomePageState（）；
}
类_HomePageState扩展状态{
映射_source={ConnectivityResult.none:false}；
MyConnectivity\u connectivity=MyConnectivity.instance；
@凌驾
void initState（）{
super.initState（）；
_连接。初始化（）；
_connectivity.myStream.listen（（源代码）{
设置状态（（）=>_source=source）；
});
}
@凌驾
小部件构建（构建上下文）{
字符串字符串；
开关（_source.keys.toList（）[0]）{
案例连接结果。无：
string=“离线”；
打破
case ConnectivityResult.mobile：
string=“移动：在线”；
打破
案例连接yresult.wifi：
string=“WiFi:在线”；
}
返回脚手架(
appBar:appBar（标题：文本（“互联网”）），
正文：居中（子项：文本（$string），样式：TextStyle（fontSize:36）），
);
}
@凌驾
无效处置（）{
_connectivity.dispostream（）；
super.dispose（）；
}
}
类连接{
MyConnectivity._internal（）；
静态最终MyConnectivity_实例=MyConnectivity._internal（）；
静态MyConnectivity get instance=>\u instance；
连接性=连接性（）；
StreamController=StreamController.broadcast（）；
Stream get myStream=>controller.Stream；
void initialise（）异步{
ConnectivityResult结果=等待连接。检查连接（）；
_检查状态（结果）；
connectivity.onConnectivityChanged.listen（（结果）{
_检查状态（结果）；
});
}
void\u checkStatus（ConnectivityResult结果）异步{
bool isOnline=false；
试一试{
最终结果=wait InternetAddress.lookup（'example.com'）；
if（result.isNotEmpty&&result[0].rawAddress.isNotEmpty）{
isOnline=真；
}否则
isOnline=false；
}关于SocketException捕获（41;{
isOnline=false；
}
add（{result:isOnline}）；
}
void disposeStream（）=>controller.close（）；
}

我觉得这是可靠的，更令人信服：

Future<bool> connectivityChecker() async {
  var connected = false;
  print("Checking internet...");
  try {
    final result = await InternetAddress.lookup('google.com');
    final result2 = await InternetAddress.lookup('facebook.com');
    final result3 = await InternetAddress.lookup('microsoft.com');
    if ((result.isNotEmpty && result[0].rawAddress.isNotEmpty) ||
        (result2.isNotEmpty && result2[0].rawAddress.isNotEmpty) ||
        (result3.isNotEmpty && result3[0].rawAddress.isNotEmpty)) {
      print('connected..');
      connected = true;
    } else {
      print("not connected from else..");
      connected = false;
    }
  } on SocketException catch (_) {
    print('not connected...');
    connected = false;
  }
  return connected;
}

Future connectivityChecker（）异步{
var=false；
打印（“检查互联网…”）；
试一试{
最终结果=等待InternetAddress.lookup（'google.com'）；
最终结果2=等待InternetAddress.lookup（'facebook.com'）；
最终结果3=等待InternetAddress.lookup（'microsoft.com'）；
if（（result.isNotEmpty&&result[0].rawAddress.isNotEmpty）||
（result2.isNotEmpty&&result2[0].rawAddress.isNotEmpty）||
（result3.isNotEmpty&&result3[0].rawAddress.isNotEmpty）
Future<bool> connectivityChecker() async {
  var connected = false;
  print("Checking internet...");
  try {
    final result = await InternetAddress.lookup('google.com');
    final result2 = await InternetAddress.lookup('facebook.com');
    final result3 = await InternetAddress.lookup('microsoft.com');
    if ((result.isNotEmpty && result[0].rawAddress.isNotEmpty) ||
        (result2.isNotEmpty && result2[0].rawAddress.isNotEmpty) ||
        (result3.isNotEmpty && result3[0].rawAddress.isNotEmpty)) {
      print('connected..');
      connected = true;
    } else {
      print("not connected from else..");
      connected = false;
    }
  } on SocketException catch (_) {
    print('not connected...');
    connected = false;
  }
  return connected;
}