smartledz_wifi_test/lib/main.dart

import 'dart:async';
import 'dart:convert';

import 'package:dart_ping/dart_ping.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:smartledz_wifi_test/plugin/wifi_plugin.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:smartledz_wifi_test/models/wifi_model.dart';
import 'package:smartledz_wifi_test/utils/modal.dart';
import 'package:smartledz_wifi_test/widgets/button_for_block.dart';
import 'package:smartledz_wifi_test/widgets/wifi_item.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return ScreenUtilInit(
      builder: (BuildContext context, Widget? child) {
        return MaterialApp(
          title: 'FX430 WIFI测试',
          theme: ThemeData(
            primarySwatch: Colors.blue,
          ),
          home: Scaffold(
            body: Column(
              children: [
                Container(
                  color: Colors.blue,
                  alignment: Alignment.center,
                  child: SafeArea(
                    left: false,
                    right: false,
                    bottom: false,
                    child: Container(
                      alignment: Alignment.center,
                      height: 50.h,
                      child: Text("FX430 WIFI测试", style: TextStyle(color: Colors.white, fontSize: 20.sp)),
                    ),
                  ),
                ),
                const Expanded(
                  child: WifiList(),
                )
              ],
            ),
          ),
        );
      },
    );
  }
}

class WifiList extends StatefulWidget {
  const WifiList({Key? key}) : super(key: key);

  @override
  State<WifiList> createState() => _WifiListState();
}

class _WifiListState extends State<WifiList> {

  final List<WifiModel> _wifiList = []; // 扫描的wifi列表
  final List<String> _selectWifiList = []; // 已选择的wifi的bssid标识列表
  void Function()? _connectCallback; // 连接成功回调
  void Function()? _disconnectCallback; // 断开连接回调

  @override
  void initState() {
    super.initState();

    var eventChannel = const EventChannel('native_event_channel');
    eventChannel.receiveBroadcastStream().listen((dataStr) {
      Map jsonArr = jsonDecode(dataStr);
      debugPrint("收到通知事件 ---> $jsonArr");
      switch(jsonArr["cmd"]){

        case "scanResult": // 扫描
          setState(() {
            for (var element in _wifiList) { // 已存在则跳过
              if(element.bssid == jsonArr["bssid"]) return;
            }
            _wifiList.add(WifiModel(
                ssid: jsonArr["ssid"],
                bssid: jsonArr["bssid"],
                rssi: int.parse(jsonArr["level"])
            ));
          });
          break;

        case "scanComplete": // 扫描完成
          setState(() { // 检查已选列表的wifi是否真实存在
            _selectWifiList.removeWhere((bssid){
              for(WifiModel wifiModel in _wifiList){ // 已存在则不删除
                if(wifiModel.bssid == bssid) return false;
              }
              return true;
            });
          });
          break;

        case "connected": // 连接成功
          _connectCallback?.call();
          break;

        case "disconnect": // 断开连接
          debugPrint("断开连接回调    _____> ");
          _disconnectCallback?.call();
          break;
      }
    });

    startScanWifi();
  }

  // 扫描wifi
  void startScanWifi([void Function()? callback]){
    _wifiList.clear();
    WiFiPlugin.startScan();
    Future.delayed(const Duration(seconds: 3), (){
      callback?.call();
    });
  }

  // 开始测试
  void startTest(){
    if(_wifiList.isEmpty){
      Modal.toast(msg: "wifi列表为空，无法测试");
      return;
    }

    if(_selectWifiList.isNotEmpty){ // 有选中的wifi，则只处理选中的wifi
      eachTestWifiList(true);
      return;
    }

    // 处理全部wifi
    eachTestWifiList(false);
  }

  // 循环测试wifi列表
  void eachTestWifiList(bool isSelect, [int index=0]){
    debugPrint("$isSelect  $index");
    int wifiIndex = index;
    if(isSelect == true){ // 处理选中设备
      if(index > _selectWifiList.length){ // 处理完成
        return;
      }
      for(int i=0; i<_wifiList.length; i++){
        if(_wifiList[i].bssid == _selectWifiList[index]){
          wifiIndex = i; // 获取选中设备在wifi列表中的索引值
          break;
        }
      }
    }else{
      if(index > _wifiList.length){ // 处理完成
        return;
      }
    }

    WifiModel wifiModel = _wifiList[wifiIndex];

    setState(()=>_wifiList[wifiIndex].result="正在连接");
    debugPrint("开始连接wifi  ssid --> ${wifiModel.ssid}   bssid --> ${wifiModel.bssid}");

    var timer = Timer(const Duration(seconds: 5), (){ // 连接超时检测
      _connectCallback = null;
      setState(()=>_wifiList[wifiIndex].result="连接失败");
      eachTestWifiList(isSelect, index+1); // 开始测试下一个设备
    });

    _connectCallback = (){
      timer.cancel(); // 销毁连接超时检测定时器

      debugPrint("wifi  --->  连接成功");
      setState(()=>_wifiList[wifiIndex].result="正在测试");

      final ping = Ping('192.168.16.254', count: 3);
      int? ttl; // ping检测结果

      ping.stream.listen((event) {
        debugPrint("ping   -->   $event");
        if(event.response?.ttl != null){
          ttl = event.response!.ttl;
        }
      });

      Future.delayed(const Duration(seconds: 3), (){
        if(ttl != null){
          setState(()=>_wifiList[wifiIndex].result="测试通过");
        }else{
          setState(()=>_wifiList[wifiIndex].result="未通过");
        }

        _disconnectCallback = (){ // 断开成功的回调
          eachTestWifiList(isSelect, index+1); // 开始测试下一个设备
        };
        WiFiPlugin.disconnect();
      });
    };
    WiFiPlugin.connect(wifiModel.ssid, wifiModel.bssid, "12345678");
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Expanded(
          child: ListView(
            padding: EdgeInsets.zero,
            children: List.generate(_wifiList.length, (index){
              WifiModel wifi = _wifiList[index];
              return WifiItem(
                wifiModel: wifi, // wifi模型
                active: _selectWifiList.contains(wifi.bssid), // 是否选中状态
                onTap: (WifiModel wifiModel){ // 列表点击事件
                  setState(() {
                    if(_selectWifiList.contains(wifi.bssid)){ // 已选中，则取消选中
                      _selectWifiList.remove(wifi.bssid);
                    }else{
                      _selectWifiList.add(wifi.bssid);
                    }
                  });
                },
              );
            }),
          ),
        ),
        Row(
          children: [
            ButtonForBlock(
              title: "刷新列表",
              fontSize: 20.sp,
              radius: 0,
              bgColor: const Color(0xFFFFAA00),
              activeBgColor: const Color(0xFFAA8800),
              width: MediaQuery.of(context).size.width/2,
              height: 55.sp,
              onTap: (){
                Modal.openLoading(context: context, tip: "正在扫描wifi");
                startScanWifi((){
                  Navigator.pop(context);
                });
              },
            ),
            ButtonForBlock(
              title: "开始测试",
              fontSize: 20.sp,
              radius: 0,
              width: MediaQuery.of(context).size.width/2,
              height: 55.sp,
              onTap: startTest,
            )
          ],
        )
      ],
    );
  }
}