Flutter封装Coap

前言

我们根据Coap数据通信流程写一个公共组件，用户只要在原本的组件外嵌套这个公共组件就可以使用Coap的功能，这样做更加的方便便捷。

具体步骤

封装一个udp函数

• 创建一个工厂函数，工厂函数初始化时监听广播数据
• 发送广播函数：入参有发送的内容，目标的ip地址（默认是255.255.255.255）、ip端口（默认端口为1234）

  import 'dart:async';
  import 'dart:io';
   
  import 'package:my_app/common/value/serve.dart';
   
  class UDPClient {
    factory UDPClient() => _getInstance();
    static UDPClient get instance => _getInstance();
    static UDPClient? _instance;
    late RawDatagramSocket udpSocket;
    final StreamController<List<int>> _getDataController =
        StreamController.broadcast(); //监听数据流的控制器
    StreamController get getDataController => _getDataController; //获取数据流的控制器
   
    //初始化
    static UDPClient _getInstance() {
      _instance ??= UDPClient._internal();
      return _instance!;
    }
   
    //创建一个UDPClient实例
    UDPClient._internal() {
      (InternetAddress.lookup('pool.ntp.org')).then((value) {
        var serverAddress = value.first;
        // print("获取到的数据:----${serverAddress.type}-----${InternetAddress.anyIPv4}");
        RawDatagramSocket.bind(
                serverAddress.type == InternetAddressType.IPv6
                    ? InternetAddress.anyIPv6
                    : InternetAddress.anyIPv4,
                0)
            .then((value) {
          udpSocket = value;
          udpSocket.listen(handleUDPDatagram);
          udpSocket.broadcastEnabled = true;
        });
      });
    }
    //断开连接
    void disconnectFromUDP() {
      udpSocket.close();
      _instance = null;
    }
   
    //监听到的数据
    void handleUDPDatagram(RawSocketEvent event) {
      if (event == RawSocketEvent.read) {
        Datagram? datagram = udpSocket.receive();
        if (datagram != null) {
          List<int> data = datagram.data;
          // print("广播接收内容:$data");
          _getDataController.sink.add(data);
        }
      }
    }
   
    //发送数据
    void sendUDPData(
      List<int> data, {
      String ip = '255.255.255.255',
      int port = UDP_PORT,
    }) {
      print("${InternetAddress(ip)}");
      udpSocket.send(data, InternetAddress(ip), port);
    }
  }

封装一个Coap函数

• 创建一个Coap的工厂函数，可以传入ip地址和端口号

• 如果ip、port改变了则会创建一个工厂函数

• 封装Get、post、postBytes、put函数

  import 'dart:async';

  import 'package:coap/coap.dart';
  import 'package:my_app/common/value/serve.dart';
  import 'package:typed_data/typed_data.dart';

  import '../value/coap_config.dart';

  class CoapClientUtil {
  factory CoapClientUtil({String? host, int? port}) =>
  _getInstance(host: host, port: port);
  static CoapClientUtil get instance => _getInstance(host: _currentHost);
  static CoapClientUtil? _instance;
  static CoapClient? client;
  static String _currentHost = COAP_API_URL;
  static int _currentPort = COAP_PORT;

  static CoapClientUtil _getInstance({String? host, int? port}) {
    String localHost = host ?? COAP_API_URL;
    int localPort = port ?? COAP_PORT;
    if (_instance == null ||
        _currentHost != localHost ||
        _currentPort != localPort) {
      _instance = CoapClientUtil._internal(localHost, localPort);
      _currentHost = localHost;
      _currentPort = localPort;
    }
    return _instance!;
  }
  
  CoapClientUtil._internal(String host, int port) {
    CoapConfig conf = CoapConfig();
    var baseUri = Uri(scheme: 'coap', host: host, port: port);
    client = CoapClient(baseUri, config: conf);
  }
  
  // 发送GET请求
  Future<CoapResponse?> get(
    final String path, {
    final CoapMediaType? accept,
    final bool confirmable = true,
    final List<Option<Object?>>? options,
    final bool earlyBlock2Negotiation = false,
    final int maxRetransmit = 0,
    final CoapMulticastResponseHandler? onMulticastResponse,
  }) async {
    try {
      var response = await client!.get(
        path,
        accept: accept,
        confirmable: confirmable,
        options: options,
        earlyBlock2Negotiation: earlyBlock2Negotiation,
        maxRetransmit: maxRetransmit,
        onMulticastResponse: onMulticastResponse,
      );
      return response;
    } catch (e) {
      print("错误的内容:${e}");
      return null;
    }
  }
  
  // 发送POST请求
  Future<CoapResponse?> post(
    final String path, {
    required final String payload,
    final CoapMediaType? format,
    final CoapMediaType? accept,
    final bool confirmable = true,
    final List<Option<Object?>>? options,
    final bool earlyBlock2Negotiation = false,
    final int maxRetransmit = 0,
    final CoapMulticastResponseHandler? onMulticastResponse,
  }) async {
    try {
      var response = await client!.post(
        path,
        payload: payload,
        format: format,
        accept: accept,
        confirmable: confirmable,
        options: options,
        earlyBlock2Negotiation: earlyBlock2Negotiation,
        maxRetransmit: maxRetransmit,
        onMulticastResponse: onMulticastResponse,
      );
      return response;
    } catch (e) {
      print("错误的内容:${e}");
      return null;
    }
  }
  
  /// 发送post请求,且携带的参数为二进制数组
  /// 需要注意的是如果返回的数据也是二进制数组则打印的response中的Payload为<<<< Payload incomplete >>>>>
   这是因为展示的payload走的是res.payloadString,看下发源码可知,转换成utf8抛出异常了,我们只要拿数据的时候使用res.payload即可
  /// String get payloadString {
  ///   final payload = this.payload;
  ///   if (payload.isNotEmpty) {
  ///     try {
  ///       final ret = utf8.decode(payload);
  ///       return ret;
  ///     } on FormatException catch (_) {
  ///       // The payload may be incomplete, if so and the conversion
  ///       // fails indicate this.
  ///       return '<<<< Payload incomplete >>>>>';
  ///     }
  ///   }
  ///   return '';
  /// }
  
  Future<CoapResponse?> postBytes(
    final String path, {
    required final Uint8Buffer payload,
    final CoapMediaType? format,
    final CoapMediaType? accept,
    final bool confirmable = true,
    final List<Option<Object?>>? options,
    final bool earlyBlock2Negotiation = false,
    final int maxRetransmit = 0,
    final CoapMulticastResponseHandler? onMulticastResponse,
  }) async {
    try {
      var response = await client!.postBytes(
        path,
        payload: payload,
        format: format,
        accept: accept,
        confirmable: confirmable,
        options: options,
        earlyBlock2Negotiation: earlyBlock2Negotiation,
        maxRetransmit: maxRetransmit,
        onMulticastResponse: onMulticastResponse,
      );
      return response;
    } catch (e) {
      print("错误的内容:${e}");
      return null;
    }
  }
  
  // 发送PUT请求
  Future<CoapResponse?> put(
    final String path, {
    required final String payload,
    final CoapMediaType? format,
    final CoapMediaType? accept,
    final bool confirmable = true,
    // final List<Uint8Buffer>? etags,
    final MatchEtags matchEtags = MatchEtags.onMatch,
    final List<Option<Object?>>? options,
    final bool earlyBlock2Negotiation = false,
    final int maxRetransmit = 0,
    final CoapMulticastResponseHandler? onMulticastResponse,
  }) async {
    try {
      var response = await client!.put(
        path,
        payload: payload,
        format: format,
        accept: accept,
        confirmable: confirmable,
        // etags: etags,
        matchEtags: matchEtags,
        options: options,
        earlyBlock2Negotiation: earlyBlock2Negotiation,
        maxRetransmit: maxRetransmit,
        onMulticastResponse: onMulticastResponse,
      );
      return response;
    } catch (e) {
      print("错误的内容:${e}");
      return null;
    }
  }
  
  close() {
    client?.close();
  }
  
  disply() {
    client?.close();
    client = null;
    _instance = null;
  }
  

  }

封装一个通用组件

• 传参内容：mac地址、Widget、key
  • mac地址：因为通信协议中地址需要使用mac地址
  • Widget：要展示的界面
  • key：根据key值调用封装组件中的函数
• 初始化逻辑：Coap数据通信流程
• 如果要进行界面跳转

  • 调用setDispose，关闭coap、udp等信息

  • 同步界面跳转

  • 创建一个定时器，定时器中包含初始化udp、coap

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

    import 'package:coap/coap.dart';
    import 'package:connectivity_plus/connectivity_plus.dart';
    import 'package:flutter/material.dart';
    import 'package:my_app/common/utils/coap.dart';
    import 'package:my_app/common/utils/fun.dart';
    import 'package:my_app/common/utils/udp.dart';
    import 'package:my_app/pages/device_settings/time_switch_addtime/bottom_picker.dart';
    import 'package:typed_data/typed_data.dart';

    ///macStr 是测试的,后期要改
    class CoapClientPackage extends StatefulWidget {
    const CoapClientPackage({
    super.key,
    this.mac = '11:22:33:44:55:66',
    required this.widget,
    });
    final String mac;
    final Widget widget;

    @override
    State<CoapClientPackage> createState() => CoapClientPackageState();
    }

    class CoapClientPackageState extends State<CoapClientPackage> {
    StreamSubscription? _networkStatusSubscription; //监听设备的网络类型
    CoapClientUtil? coapClient;

    //udp获取到的数据
    UDPClient? udpClient;
    StreamSubscription? _sacnSubscription;
    bool isCoap = false;
    Timer? timer;
    @override
    void initState() {
    super.initState();
    // initUDP();

    // //监听移动终端联网方式
    // _listenNetworkStatus();
    getinitState();
    

    }

    getinitState() {
    print("初始化");
    initUDP();
    //监听移动终端联网方式
    _listenNetworkStatus();
    }

    setDispose() {
    print("移除");
    _networkStatusSubscription?.cancel(); //取消监听
    coapClient?.disply(); //关闭coap连接
    udpClient?.disconnectFromUDP(); //关闭udp连接
    _sacnSubscription?.cancel(); //取消监听
    timer?.cancel(); //取消定时器
    }

    @override
    void dispose() {
    setDispose();
    super.dispose();
    }

    initUDP() {
    udpClient = UDPClient.instance;
    _sacnSubscription?.cancel();
    _sacnSubscription = udpClient?.getDataController.stream.listen((data) {
    if (data is List<int>) {
    print("这是哪个数据:data"); setState(() { isCoap = false; }); switch (data[2]) { case 129: // if (data[0] == 170 && data.length == 15 && data[14] == 85) { //将从data[7]开始截取数组 // List macArr = data.sublist(3, 9); //截取mac地址 // //将十进制数组转换成十六进制mac并添加: // String macStr = // macArr.map((e) => e.toRadixString(16).padLeft(2, '0')).join(':'); // print("macArr:macArr -----{macStr}"); timer?.cancel(); String serverIp = "{data[9]}.{data[10]}.{data[11]}.${data[12]}";

              print("获取到了ip地址:$serverIp");
              //创建一个coap服务
              coapClient = CoapClientUtil(
                host: serverIp,
                port: 5683,
              );
              setState(() {
                isCoap = true;
              });
            }
    
            break;
          default:
        }
      }
    });
    

    }

    //监听移动终端联网方式
    void _listenNetworkStatus() async {
    _networkStatusSubscription?.cancel(); //取消之前的监听
    bool isWif = await isWifi();
    if (isWif) {
    isWifiAfter();
    } else {
    _networkStatusSubscription = Connectivity()
    .onConnectivityChanged
    .listen((ConnectivityResult result) {
    if (result == ConnectivityResult.wifi) {
    //当前的类型是WiFi
    isWifiAfter();
    } else {
    setState(() {
    isCoap = false;
    });
    }
    });
    }
    }

    isWifiAfter() {
    print('当前的类型是WiFi');

    //这里需要在发送mac地址,这里使用模拟的数据
    String macStr = widget.mac;
    // String macStr = '11:22:33:44:55:66';
    
    //将macStr装换成List<int>
    List<int> macArr =
        macStr.split(':').map((e) => int.parse(e, radix: 16)).toList();
    List<int> sendData = sendCoapData('01', macArr);
    print("-----=====------macArr:${sendData},macStr");
    Timer(Duration(seconds: 1), () {
      udpClient?.sendUDPData(sendData, port: 1234);
    });
    timer?.cancel();
    timer = Timer.periodic(Duration(seconds: 3), (timer) {
      if (udpClient != null) {
        try {
          udpClient?.sendUDPData(sendData, port: 1234);
        } catch (e) {
          print("发送出现了问题:${e}");
        }
      } else {
        print("为空");
      }
    });
    

    }

    //发送coap请求
    Future<CoapResponse?> sendCoap(String payload) async {
    String macStr = widget.mac;
    // String macStr = '11:22:33:44:55:66';
    var res = await coapClient?.post('/api/v1/$macStr/rpc',
    accept: CoapMediaType.applicationJson, payload: payload);
    return res;
    }

    //发送透传数据
    Future<CoapResponse?> sendTranCoap(String payload) async {
    String macStr = widget.mac;
    // String macStr = '11:22:33:44:55:66';
    var res = await coapClient?.post('/api/v1/$macStr/trans',
    accept: CoapMediaType.applicationJson, payload: payload);
    return res;
    }

    //发送透传数据
    Future<CoapResponse?> sendTranCoap1(Uint8Buffer payload) async {
    String macStr = widget.mac;
    // String macStr = '11:22:33:44:55:66';
    var res = await coapClient?.postBytes('/api/v1/$macStr/trans',
    accept: CoapMediaType.applicationJson, payload: payload);
    return res;
    }

    @override
    Widget build(BuildContext context) {
    return widget.widget;
    }
    }