refactor: overall improvements

packages/wifi_basic/lib/src/extensions.dart

@@ -1,22 +1,42 @@
 import 'package:wifi_basic/wifi_basic.dart';
 
-extension ToEnumExtension on int? {
-  WiFiGenerations toWifiGeneration() {
-    if (this == null || this! < 0 || this! > 6) {
-      return WiFiGenerations.unknown;
+extension WiFiGenerationsExtension on WiFiGenerations {
+  static WiFiGenerations fromInt(int? value) {
+    switch (value) {
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+        return WiFiGenerations.legacy;
+      case 4:
+        return WiFiGenerations.wifi4;
+      case 5:
+        return WiFiGenerations.wifi5;
+      case 6:
+        return WiFiGenerations.wifi6;
+      default:
+        return WiFiGenerations.unknown;
     }
-    // legacy - if less than 3
-    if (this! <= 3) return WiFiGenerations.legacy;
-    // convert generationInt -> generationEnum
-    return WiFiGenerations.values[this! - 2];
   }
+}
 
-  WiFiNetworkSecurity toWifiNetworkSecurity() {
-    if (this == null ||
-        this! < 0 ||
-        this! > WiFiNetworkSecurity.values.length) {
-      return WiFiNetworkSecurity.unknown;
+extension WiFiNetworkSecurityExtension on WiFiNetworkSecurity {
+  static WiFiNetworkSecurity fromInt(int? value) {
+    switch (value) {
+      case 0:
+        return WiFiNetworkSecurity.unknown;
+      case 1:
+        return WiFiNetworkSecurity.none;
+      case 2:
+        return WiFiNetworkSecurity.wep;
+      case 3:
+        return WiFiNetworkSecurity.wpa;
+      case 4:
+        return WiFiNetworkSecurity.wpa2;
+      case 5:
+        return WiFiNetworkSecurity.wpa3;
+      default:
+        return WiFiNetworkSecurity.unknown;
     }
-    return WiFiNetworkSecurity.values[this! + 1];
   }
 }

packages/wifi_basic/lib/wifi_basic.dart

@@ -1,38 +1,12 @@
 import 'package:async/async.dart';
+import 'package:collection/collection.dart';
+import 'package:flutter/cupertino.dart';
 import 'package:flutter/services.dart';
 import 'package:wifi_basic/src/extensions.dart';
 
-enum WiFiGenerations { unknown, legacy, wifi4, wifi5, wifi6 }
-
-enum WiFiNetworkSecurity { unknown, none, wep, wpa, wpa2, wpa3 }
-
-class WiFiInfo {
-  final String ssid;
-  final String bssid;
-  final WiFiNetworkSecurity security;
-  final bool isHidden;
-  final int rssi;
-  final double signalStrength;
-  final bool hasInternet;
-  final WiFiGenerations generation;
-
-  bool get isNull => ssid.isEmpty;
-
-  WiFiInfo._fromMap(Map map)
-      : ssid = map["ssid"],
-        bssid = map["bssid"],
-        security = (map["security"] as int?).toWifiNetworkSecurity(),
-        isHidden = map["isHidden"],
-        rssi = map["rssi"],
-        signalStrength = map["signalStrength"],
-        hasInternet = map["hasInternet"],
-        generation = (map["generation"] as int?).toWifiGeneration();
-
-  @override
-  String toString() => "ssid; $ssid; bssid: $bssid; security: $security; "
-      "isHidden: $isHidden; rssi: $rssi; signalStrength: $signalStrength; "
-      "hasInternet: $hasInternet; generation: $generation";
-}
+part 'wifi_generations.dart';
+part 'wifi_info.dart';
+part 'wifi_network_security.dart';
 
 class WiFiBasic {
   WiFiBasic._();
@@ -42,21 +16,40 @@ class WiFiBasic {
   final _isSupportedMemo = AsyncMemoizer<bool>();
   final _getGenerationMemo = AsyncMemoizer<WiFiGenerations>();
 
-  Future<bool> isSupported() => _isSupportedMemo
-      .runOnce(() async => await _channel.invokeMethod('isSupported'));
-
-  Future<WiFiGenerations> getGeneration() => _getGenerationMemo.runOnce(
-      () async => (await _channel.invokeMethod("getGeneration") as int?)
-          .toWifiGeneration());
-
-  Future<bool> isEnabled() async => await _channel.invokeMethod('isEnabled');
-
-  Future<bool> setEnabled(bool enabled) async =>
-      await _channel.invokeMethod('setEnabled', {"enabled": enabled});
-
-  Future<void> openSettings() async =>
-      await _channel.invokeMethod("openSettings");
-
-  Future<WiFiInfo> getCurrentInfo() async =>
-      WiFiInfo._fromMap(await _channel.invokeMapMethod("getCurrentInfo") ?? {});
+  Future<bool> isSupported() {
+    return _isSupportedMemo.runOnce(() async {
+      return (await _channel.invokeMethod<bool>('isSupported'))!;
+    });
+  }
+
+  Future<WiFiGenerations> getGeneration() {
+    return _getGenerationMemo.runOnce(() async {
+      final generation = await _channel.invokeMethod<int?>("getGeneration");
+      return WiFiGenerationsExtension.fromInt(generation);
+    });
+  }
+
+  Future<bool> isEnabled() async {
+    return (await _channel.invokeMethod<bool>('isEnabled'))!;
+  }
+
+  Future<bool> setEnabled(bool enabled) async {
+    return (await _channel.invokeMethod<bool>(
+      'setEnabled',
+      {"enabled": enabled},
+    ))!;
+  }
+
+  Future<void> openSettings() async {
+    await _channel.invokeMethod<void>("openSettings");
+  }
+
+  Future<WiFiInfo?> getCurrentInfo() async {
+    final result =
+        await _channel.invokeMapMethod<String, dynamic>("getCurrentInfo");
+
+    if (result == null) return null;
+
+    return WiFiInfo.fromMap(result);
+  }
 }

packages/wifi_basic/lib/wifi_generations.dart

@@ -0,0 +1,3 @@
+part of 'wifi_basic.dart';
+
+enum WiFiGenerations { unknown, legacy, wifi4, wifi5, wifi6 }

packages/wifi_basic/lib/wifi_info.dart

@@ -0,0 +1,62 @@
+part of 'wifi_basic.dart';
+
+class WiFiInfo {
+  static const Equality _equality = DeepCollectionEquality();
+
+  final String ssid;
+  final String bssid;
+  final WiFiNetworkSecurity security;
+  final bool isHidden;
+  final int rssi;
+  final double signalStrength;
+  final bool hasInternet;
+  final WiFiGenerations generation;
+
+  bool get isNull => ssid.isEmpty;
+
+  @visibleForTesting
+  WiFiInfo.fromMap(Map map)
+      : ssid = map["ssid"] as String,
+        bssid = map["bssid"] as String,
+        security =
+            WiFiNetworkSecurityExtension.fromInt(map["security"] as int?),
+        isHidden = map["isHidden"] as bool,
+        rssi = map["rssi"] as int,
+        signalStrength = map["signalStrength"] as double,
+        hasInternet = map["hasInternet"] as bool,
+        generation =
+            WiFiGenerationsExtension.fromInt(map["generation"] as int?);
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (runtimeType == other.runtimeType &&
+          other is WiFiInfo &&
+          _equality.equals(ssid, other.ssid) &&
+          _equality.equals(bssid, other.bssid) &&
+          _equality.equals(security, other.security) &&
+          _equality.equals(isHidden, other.isHidden) &&
+          _equality.equals(rssi, other.rssi) &&
+          _equality.equals(signalStrength, other.signalStrength) &&
+          _equality.equals(hasInternet, other.hasInternet) &&
+          _equality.equals(generation, other.generation));
+
+  @override
+  int get hashCode => Object.hash(
+        runtimeType,
+        _equality.hash(ssid),
+        _equality.hash(bssid),
+        _equality.hash(security),
+        _equality.hash(isHidden),
+        _equality.hash(rssi),
+        _equality.hash(signalStrength),
+        _equality.hash(hasInternet),
+        _equality.hash(generation),
+      );
+
+  @override
+  String toString() => "WiFiInfo(ssid: $ssid, bssid: $bssid, "
+      "security: $security, isHidden: $isHidden, rssi: $rssi, "
+      "signalStrength: $signalStrength, hasInternet: $hasInternet, "
+      "generation: $generation)";
+}

packages/wifi_basic/lib/wifi_network_security.dart

@@ -0,0 +1,3 @@
+part of 'wifi_basic.dart';
+
+enum WiFiNetworkSecurity { unknown, none, wep, wpa, wpa2, wpa3 }

packages/wifi_basic/pubspec.yaml

@@ -11,6 +11,7 @@ dependencies:
   flutter:
     sdk: flutter
   async: ^2.8.0
+  collection: ^1.15.0
 
 dev_dependencies:
   flutter_test:

packages/wifi_basic/test/wifi_basic_test.dart

@@ -2,10 +2,9 @@ import 'dart:math';
 
 import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:wifi_basic/src/extensions.dart';
 import 'package:wifi_basic/wifi_basic.dart';
 
-import 'package:wifi_basic/src/extensions.dart' show ToEnumExtension;
-
 void main() {
   const channel = MethodChannel('wifi_basic');
   final mockHandlers = <String, Function(dynamic arguments)>{};
@@ -86,52 +85,57 @@ void main() {
   });
 
   test("test getCurrentInfo", () async {
-    mockHandlers["getCurrentInfo"] = (_) => {
-          "ssid": "my-wifi",
-          "bssid": "02:00:00:00:00:00",
-          "security": 0,
-          "isHidden": false,
-          "rssi": -100,
-          "signalStrength": 1.0,
-          "hasInternet": true,
-          "generation": -1,
-        };
+    final value = {
+      "ssid": "my-wifi",
+      "bssid": "02:00:00:00:00:00",
+      "security": 0,
+      "isHidden": false,
+      "rssi": -100,
+      "signalStrength": 1.0,
+      "hasInternet": true,
+      "generation": -1,
+    };
+    mockHandlers["getCurrentInfo"] = (_) => value;
     final info = await WiFiBasic.instance.getCurrentInfo();
-    expect(info.ssid, "my-wifi");
-    expect(info.bssid, "02:00:00:00:00:00");
-    expect(info.security, WiFiNetworkSecurity.none);
-    expect(info.isHidden, false);
-    expect(info.rssi, -100);
-    expect(info.signalStrength, 1.0);
-    expect(info.hasInternet, true);
-    expect(info.generation, WiFiGenerations.unknown);
+
+    expect(info, WiFiInfo.fromMap(value));
   });
 
-  test("test ToEnumExtension.toWifiGeneration", () async {
-    // test for unknown
-    expect((-1).toWifiGeneration(), WiFiGenerations.unknown);
-    // test for legacy
-    expect(Random().nextInt(3).toWifiGeneration(), WiFiGenerations.legacy);
-    // test for wifi4, wifi5 and wifi6
-    expect(4.toWifiGeneration(), WiFiGenerations.wifi4);
-    expect(5.toWifiGeneration(), WiFiGenerations.wifi5);
-    expect(6.toWifiGeneration(), WiFiGenerations.wifi6);
-    // test for unknown again
-    expect(
-        (7 + Random().nextInt(10)).toWifiGeneration(), WiFiGenerations.unknown);
+  test("test WiFiGenerationsExtension", () {
+    final intValues = [-1, 0, 1, 2, 3, 4, 5, 6, 7, null];
+
+    final enumValues = intValues.map(WiFiGenerationsExtension.fromInt).toList();
+
+    expect(enumValues, [
+      WiFiGenerations.unknown,
+      WiFiGenerations.legacy,
+      WiFiGenerations.legacy,
+      WiFiGenerations.legacy,
+      WiFiGenerations.legacy,
+      WiFiGenerations.wifi4,
+      WiFiGenerations.wifi5,
+      WiFiGenerations.wifi6,
+      WiFiGenerations.unknown,
+      WiFiGenerations.unknown,
+    ]);
   });
 
-  test("test ToEnumExtension.toWifiNetworkSecurity", () {
-    // test for unknown
-    expect((-1).toWifiNetworkSecurity(), WiFiNetworkSecurity.unknown);
-    // test for values
-    expect(0.toWifiNetworkSecurity(), WiFiNetworkSecurity.none);
-    expect(1.toWifiNetworkSecurity(), WiFiNetworkSecurity.wep);
-    expect(2.toWifiNetworkSecurity(), WiFiNetworkSecurity.wpa);
-    expect(3.toWifiNetworkSecurity(), WiFiNetworkSecurity.wpa2);
-    expect(4.toWifiNetworkSecurity(), WiFiNetworkSecurity.wpa3);
-    // test for unknown again
-    expect((7 + Random().nextInt(10)).toWifiNetworkSecurity(),
-        WiFiNetworkSecurity.unknown);
+  test("test WiFiNetworkSecurityExtension", () {
+    final intValues = [-1, 0, 1, 2, 3, 4, 5, 6, null];
+
+    final enumValues =
+        intValues.map(WiFiNetworkSecurityExtension.fromInt).toList();
+
+    expect(enumValues, [
+      WiFiNetworkSecurity.unknown,
+      WiFiNetworkSecurity.unknown,
+      WiFiNetworkSecurity.none,
+      WiFiNetworkSecurity.wep,
+      WiFiNetworkSecurity.wpa,
+      WiFiNetworkSecurity.wpa2,
+      WiFiNetworkSecurity.wpa3,
+      WiFiNetworkSecurity.unknown,
+      WiFiNetworkSecurity.unknown,
+    ]);
   });
 }