deprecate EncryptionType.none; fallback to EncryptionType.unknown for unrecognized values

 /// Wifi encryption type constants.
 /// Wifi encryption type constants.
 enum EncryptionType {
 enum EncryptionType {
   /// Unknown encryption type.
   /// Unknown encryption type.
-  none(0),
+  unknown(0),
 
 
   /// Not encrypted.
   /// Not encrypted.
   open(1),
   open(1),
@@ -14,10 +14,13 @@ enum EncryptionType {
 
 
   const EncryptionType(this.rawValue);
   const EncryptionType(this.rawValue);
 
 
+  @Deprecated('EncryptionType.none is deprecated. Use EncryptionType.unknown instead.')
+  static const EncryptionType none = EncryptionType.unknown;
+
   factory EncryptionType.fromRawValue(int value) {
   factory EncryptionType.fromRawValue(int value) {
     switch (value) {
     switch (value) {
       case 0:
       case 0:
-        return EncryptionType.none;
+        return EncryptionType.unknown;
       case 1:
       case 1:
         return EncryptionType.open;
         return EncryptionType.open;
       case 2:
       case 2:
@@ -25,7 +28,7 @@ enum EncryptionType {
       case 3:
       case 3:
         return EncryptionType.wep;
         return EncryptionType.wep;
       default:
       default:
-        throw ArgumentError.value(value, 'value', 'Invalid raw value.');
+        return EncryptionType.unknown;
     }
     }
   }
   }
 
 

@@ -5,7 +5,7 @@ import 'package:mobile_scanner/src/enums/encryption_type.dart';
 class WiFi {
 class WiFi {
   /// Construct a new [WiFi] instance.
   /// Construct a new [WiFi] instance.
   const WiFi({
   const WiFi({
-    this.encryptionType = EncryptionType.none,
+    this.encryptionType = EncryptionType.unknown,
     this.ssid,
     this.ssid,
     this.password,
     this.password,
   });
   });

@@ -5,7 +5,7 @@ void main() {
   group('$EncryptionType tests', () {
   group('$EncryptionType tests', () {
     test('can be created from raw value', () {
     test('can be created from raw value', () {
       const values = <int, EncryptionType>{
       const values = <int, EncryptionType>{
-        0: EncryptionType.none,
+        0: EncryptionType.unknown,
         1: EncryptionType.open,
         1: EncryptionType.open,
         2: EncryptionType.wpa,
         2: EncryptionType.wpa,
         3: EncryptionType.wep,
         3: EncryptionType.wep,
@@ -18,20 +18,20 @@ void main() {
       }
       }
     });
     });
 
 
-    test('invalid raw value throws argument error', () {
+    test('invalid raw value returns EncryptionType.unknown', () {
       const int negative = -1;
       const int negative = -1;
       const int outOfRange = 4;
       const int outOfRange = 4;
 
 
-      expect(() => EncryptionType.fromRawValue(negative), throwsArgumentError);
+      expect(() => EncryptionType.fromRawValue(negative), EncryptionType.unknown);
       expect(
       expect(
         () => EncryptionType.fromRawValue(outOfRange),
         () => EncryptionType.fromRawValue(outOfRange),
-        throwsArgumentError,
+        EncryptionType.unknown,
       );
       );
     });
     });
 
 
     test('can be converted to raw value', () {
     test('can be converted to raw value', () {
       const values = <EncryptionType, int>{
       const values = <EncryptionType, int>{
-        EncryptionType.none: 0,
+        EncryptionType.unknown: 0,
         EncryptionType.open: 1,
         EncryptionType.open: 1,
         EncryptionType.wpa: 2,
         EncryptionType.wpa: 2,
         EncryptionType.wep: 3,
         EncryptionType.wep: 3,