Revert "Make LogicalKeyboardKey.keyLabel a getter and better (#79100)" (#79217)

dev/tools/gen_keycodes/lib/keyboard_keys_code_gen.dart

@@ -45,38 +45,38 @@ class KeyboardKeysCodeGenerator extends BaseCodeGenerator {
       definitions.write('''
 
 $firstComment  ///
-$otherComments  static const PhysicalKeyboardKey ${entry.constantName} = PhysicalKeyboardKey._(${toHex(entry.usbHidCode, digits: 8)});
+$otherComments  static const PhysicalKeyboardKey ${entry.constantName} = PhysicalKeyboardKey(${toHex(entry.usbHidCode, digits: 8)}, debugName: kReleaseMode ? null : '${entry.commentName}');
 ''');
     }
     return definitions.toString();
   }
 
-  String get _physicalDebugNames {
-    final StringBuffer result = StringBuffer();
-    for (final Key entry in keyData.data) {
-      result.write('''
-      ${toHex(entry.usbHidCode, digits: 8)}: '${entry.commentName}',
-''');
-    }
-    return result.toString();
-  }
-
   /// Gets the generated definitions of LogicalKeyboardKeys.
   String get _logicalDefinitions {
+    String escapeLabel(String label) => label.contains("'") ? 'r"$label"' : "r'$label'";
     final StringBuffer definitions = StringBuffer();
-    void printKey(int flutterId, String constantName, String commentName, {String otherComments}) {
+    void printKey(int flutterId, String keyLabel, String constantName, String commentName, {String otherComments}) {
       final String firstComment = _wrapString('Represents the logical "$commentName" key on the keyboard.');
       otherComments ??= _wrapString('See the function [RawKeyEvent.logicalKey] for more information.');
-      definitions.write('''
+      if (keyLabel == null) {
+        definitions.write('''
 
 $firstComment  ///
-$otherComments  static const LogicalKeyboardKey $constantName = LogicalKeyboardKey._(${toHex(flutterId, digits: 11)});
+$otherComments  static const LogicalKeyboardKey $constantName = LogicalKeyboardKey(${toHex(flutterId, digits: 11)}, debugName: kReleaseMode ? null : '$commentName');
 ''');
+      } else {
+        definitions.write('''
+
+$firstComment  ///
+$otherComments  static const LogicalKeyboardKey $constantName = LogicalKeyboardKey(${toHex(flutterId, digits: 11)}, keyLabel: ${escapeLabel(keyLabel)}, debugName: kReleaseMode ? null : '$commentName');
+''');
+      }
     }
 
     for (final Key entry in keyData.data) {
       printKey(
         entry.flutterId,
+        entry.keyLabel,
         entry.constantName,
         entry.commentName,
       );
@@ -89,7 +89,7 @@ $otherComments  static const LogicalKeyboardKey $constantName = LogicalKeyboardK
       final Set<String> unionNames = Key.synonyms[name].map<String>((dynamic name) {
         return upperCamelToLowerCamel(name as String);
       }).toSet();
-      printKey(Key.synonymPlane | entry.flutterId, name, Key.getCommentName(name),
+      printKey(Key.synonymPlane | entry.flutterId, entry.keyLabel, name, Key.getCommentName(name),
           otherComments: _wrapString('This key represents the union of the keys '
               '$unionNames when comparing keys. This key will never be generated '
               'directly, its main use is in defining key maps.'));
@@ -108,25 +108,6 @@ $otherComments  static const LogicalKeyboardKey $constantName = LogicalKeyboardK
     return synonyms.toString();
   }
 
-  String get _logicalKeyLabels {
-    final StringBuffer result = StringBuffer();
-    for (final Key entry in keyData.data) {
-      result.write('''
-    ${toHex(entry.flutterId, digits: 11)}: '${entry.commentName}',
-''');
-    }
-    for (final String name in Key.synonyms.keys) {
-      // Use the first item in the synonyms as a template for the ID to use.
-      // It won't end up being the same value because it'll be in the pseudo-key
-      // plane.
-      final Key entry = keyData.data.firstWhere((Key item) => item.name == Key.synonyms[name][0]);
-      result.write('''
-    ${toHex(Key.synonymPlane | entry.flutterId, digits: 11)}: '${Key.getCommentName(name)}',
-''');
-    }
-    return result.toString();
-  }
-
   /// This generates the map of USB HID codes to physical keys.
   String get _predefinedHidCodeMap {
     final StringBuffer scanCodeMap = StringBuffer();
@@ -165,9 +146,7 @@ $otherComments  static const LogicalKeyboardKey $constantName = LogicalKeyboardK
       'LOGICAL_KEY_MAP': _predefinedKeyCodeMap,
       'LOGICAL_KEY_DEFINITIONS': _logicalDefinitions,
       'LOGICAL_KEY_SYNONYMS': _logicalSynonyms,
-      'LOGICAL_KEY_KEY_LABELS': _logicalKeyLabels,
       'PHYSICAL_KEY_DEFINITIONS': _physicalDefinitions,
-      'PHYSICAL_KEY_DEBUG_NAMES': _physicalDebugNames,
     };
   }
 }

packages/flutter/lib/src/services/raw_keyboard_android.dart

@@ -194,7 +194,11 @@ class RawKeyEventDataAndroid extends RawKeyEventData {
     if (keyLabel.isNotEmpty && !LogicalKeyboardKey.isControlCharacter(keyLabel)) {
       final int combinedCodePoint = plainCodePoint & _kCombiningCharacterMask;
       final int keyId = LogicalKeyboardKey.unicodePlane | (combinedCodePoint & LogicalKeyboardKey.valueMask);
-      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(keyId);
+      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(
+        keyId,
+        keyLabel: keyLabel,
+        debugName: kReleaseMode ? null : 'Key ${keyLabel.toUpperCase()}',
+      );
     }
 
     // Look to see if the keyCode is one we know about and have a mapping for.
@@ -206,7 +210,10 @@ class RawKeyEventDataAndroid extends RawKeyEventData {
     // This is a non-printable key that we don't know about, so we mint a new
     // code with the autogenerated bit set.
     const int androidKeyIdPlane = 0x00200000000;
-    newKey ??= LogicalKeyboardKey(androidKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask);
+    newKey ??= LogicalKeyboardKey(
+      androidKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask,
+      debugName: kReleaseMode ? null : 'Unknown Android key code $keyCode',
+    );
     return newKey;
   }
 

packages/flutter/lib/src/services/raw_keyboard_fuchsia.dart

@@ -68,8 +68,11 @@ class RawKeyEventDataFuchsia extends RawKeyEventData {
     // If the key has a printable representation, then make a logical key based
     // on that.
     if (codePoint != 0) {
-      final int flutterId = LogicalKeyboardKey.unicodePlane | codePoint & LogicalKeyboardKey.valueMask;
-      return kFuchsiaToLogicalKey[flutterId] ?? LogicalKeyboardKey(LogicalKeyboardKey.unicodePlane | codePoint & LogicalKeyboardKey.valueMask);
+      return LogicalKeyboardKey(
+        LogicalKeyboardKey.unicodePlane | codePoint & LogicalKeyboardKey.valueMask,
+        keyLabel: keyLabel,
+        debugName: kReleaseMode ? null : 'Key $keyLabel',
+      );
     }
 
     // Look to see if the hidUsage is one we know about and have a mapping for.
@@ -81,7 +84,10 @@ class RawKeyEventDataFuchsia extends RawKeyEventData {
     // This is a non-printable key that we don't know about, so we mint a new
     // code with the autogenerated bit set.
     const int fuchsiaKeyIdPlane = 0x00300000000;
-    newKey ??= LogicalKeyboardKey(fuchsiaKeyIdPlane | hidUsage | LogicalKeyboardKey.autogeneratedMask);
+    newKey ??= LogicalKeyboardKey(
+      fuchsiaKeyIdPlane | hidUsage | LogicalKeyboardKey.autogeneratedMask,
+      debugName: kReleaseMode ? null : 'Ephemeral Fuchsia key code $hidUsage',
+    );
     return newKey;
   }
 

packages/flutter/lib/src/services/raw_keyboard_ios.dart

@@ -92,6 +92,7 @@ class RawKeyEventDataIos extends RawKeyEventData {
   @override
   PhysicalKeyboardKey get physicalKey => kIosToPhysicalKey[keyCode] ?? PhysicalKeyboardKey.none;
 
+
   @override
   LogicalKeyboardKey get logicalKey {
     // Look to see if the keyCode is a printable number pad key, so that a
@@ -125,7 +126,11 @@ class RawKeyEventDataIos extends RawKeyEventData {
       }
 
       final int keyId = LogicalKeyboardKey.unicodePlane | (codeUnit & LogicalKeyboardKey.valueMask);
-      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(keyId);
+      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(
+        keyId,
+        keyLabel: keyLabel,
+        debugName: kReleaseMode ? null : 'Key ${keyLabel.toUpperCase()}',
+      );
     }
 
     // Control keys like "backspace" and movement keys like arrow keys don't
@@ -136,14 +141,21 @@ class RawKeyEventDataIos extends RawKeyEventData {
     // physical key map.
     if (physicalKey != PhysicalKeyboardKey.none) {
       final int keyId = physicalKey.usbHidUsage | LogicalKeyboardKey.hidPlane;
-      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(keyId);
+      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(
+        keyId,
+        keyLabel: physicalKey.debugName ?? '',
+        debugName: physicalKey.debugName,
+      );
     }
 
     // This is a non-printable key that is unrecognized, so a new code is minted
     // with the autogenerated bit set.
     const int iosKeyIdPlane = 0x00400000000;
 
-    return LogicalKeyboardKey(iosKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask);
+    return LogicalKeyboardKey(
+      iosKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask,
+      debugName: kReleaseMode ? null : 'Unknown iOS key code $keyCode',
+    );
   }
 
   bool _isLeftRightModifierPressed(KeyboardSide side, int anyMask, int leftMask, int rightMask) {

packages/flutter/lib/src/services/raw_keyboard_linux.dart

@@ -92,7 +92,11 @@ class RawKeyEventDataLinux extends RawKeyEventData {
     if (keyLabel.isNotEmpty &&
         !LogicalKeyboardKey.isControlCharacter(keyLabel)) {
       final int keyId = LogicalKeyboardKey.unicodePlane | (unicodeScalarValues & LogicalKeyboardKey.valueMask);
-      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(keyId);
+      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(
+        keyId,
+        keyLabel: keyLabel,
+        debugName: kReleaseMode ? null : 'Key ${keyLabel.toUpperCase()}',
+      );
     }
 
     // Look to see if the keyCode is one we know about and have a mapping for.
@@ -105,7 +109,10 @@ class RawKeyEventDataLinux extends RawKeyEventData {
 
     // This is a non-printable key that we don't know about, so we mint a new
     // code with the autogenerated bit set.
-    newKey ??= LogicalKeyboardKey(linuxKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask);
+    newKey ??= LogicalKeyboardKey(
+      linuxKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask,
+      debugName: kReleaseMode ? null : 'Unknown key code $keyCode',
+    );
     return newKey;
   }
 

packages/flutter/lib/src/services/raw_keyboard_macos.dart

@@ -95,7 +95,11 @@ class RawKeyEventDataMacOs extends RawKeyEventData {
       }
 
       final int keyId = LogicalKeyboardKey.unicodePlane | (codeUnit & LogicalKeyboardKey.valueMask);
-      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(keyId);
+      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(
+        keyId,
+        keyLabel: keyLabel,
+        debugName: kReleaseMode ? null : 'Key ${keyLabel.toUpperCase()}',
+      );
     }
 
     // Control keys like "backspace" and movement keys like arrow keys don't
@@ -106,14 +110,21 @@ class RawKeyEventDataMacOs extends RawKeyEventData {
     // physical key map.
     if (physicalKey != PhysicalKeyboardKey.none) {
       final int keyId = physicalKey.usbHidUsage | LogicalKeyboardKey.hidPlane;
-      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(keyId);
+      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(
+        keyId,
+        keyLabel: physicalKey.debugName ?? '',
+        debugName: physicalKey.debugName,
+      );
     }
 
     // This is a non-printable key that is unrecognized, so a new code is minted
     // with the autogenerated bit set.
     const int macOsKeyIdPlane = 0x00500000000;
 
-    return LogicalKeyboardKey(macOsKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask);
+    return LogicalKeyboardKey(
+      macOsKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask,
+      debugName: kReleaseMode ? null : 'Unknown macOS key code $keyCode',
+    );
   }
 
   bool _isLeftRightModifierPressed(KeyboardSide side, int anyMask, int leftMask, int rightMask) {

packages/flutter/lib/src/services/raw_keyboard_web.dart

@@ -82,7 +82,10 @@ class RawKeyEventDataWeb extends RawKeyEventData {
     // This is a non-printable key that we don't know about, so we mint a new
     // code with the autogenerated bit set.
     const int webKeyIdPlane = 0x00800000000;
-    return LogicalKeyboardKey(webKeyIdPlane | code.hashCode | LogicalKeyboardKey.autogeneratedMask);
+    return LogicalKeyboardKey(
+      webKeyIdPlane | code.hashCode | LogicalKeyboardKey.autogeneratedMask,
+      debugName: kReleaseMode ? null : 'Unknown Web code "$code"',
+    );
   }
 
   @override

packages/flutter/lib/src/services/raw_keyboard_windows.dart

@@ -3,6 +3,8 @@
 // found in the LICENSE file.
 
 
+import 'package:flutter/foundation.dart';
+
 import 'keyboard_key.dart';
 import 'keyboard_maps.dart';
 import 'raw_keyboard.dart';
@@ -78,7 +80,11 @@ class RawKeyEventDataWindows extends RawKeyEventData {
     // plane.
     if (keyLabel.isNotEmpty && !LogicalKeyboardKey.isControlCharacter(keyLabel)) {
       final int keyId = LogicalKeyboardKey.unicodePlane | (characterCodePoint & LogicalKeyboardKey.valueMask);
-      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(keyId);
+      return LogicalKeyboardKey.findKeyByKeyId(keyId) ?? LogicalKeyboardKey(
+        keyId,
+        keyLabel: keyLabel,
+        debugName: kReleaseMode ? null : 'Key ${keyLabel.toUpperCase()}',
+      );
     }
     // Look to see if the keyCode is one we know about and have a mapping for.
     LogicalKeyboardKey? newKey = kWindowsToLogicalKey[keyCode];
@@ -89,7 +95,10 @@ class RawKeyEventDataWindows extends RawKeyEventData {
     // This is a non-printable key that we don't know about, so we mint a new
     // code with the autogenerated bit set.
     const int windowsKeyIdPlane = 0x00700000000;
-    newKey ??= LogicalKeyboardKey(windowsKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask);
+    newKey ??= LogicalKeyboardKey(
+      windowsKeyIdPlane | keyCode | LogicalKeyboardKey.autogeneratedMask,
+      debugName: kReleaseMode ? null : 'Unknown Windows key code $keyCode',
+    );
     return newKey;
   }
 

packages/flutter/test/services/keyboard_key_test.dart

@@ -15,14 +15,11 @@ void main() {
       // Check a modifier key
       expect(PhysicalKeyboardKey.findKeyByCode(0x000700e1), equals(PhysicalKeyboardKey.shiftLeft));
     });
-    test('Values are cached', () async {
-      expect(identical(PhysicalKeyboardKey.keyA, PhysicalKeyboardKey(PhysicalKeyboardKey.keyA.usbHidUsage)), true);
-      expect(identical(PhysicalKeyboardKey(0x12345), PhysicalKeyboardKey(0x12345)), true);
-    });
-    test('debugNames', () async {
-      expect(PhysicalKeyboardKey.keyA.debugName, 'Key A');
-      expect(PhysicalKeyboardKey.backslash.debugName, 'Backslash');
-      expect(PhysicalKeyboardKey(0x12345).debugName, 'Key with ID 0x00012345');
+    test('Equality is only based on HID code.', () async {
+      const PhysicalKeyboardKey key1 = PhysicalKeyboardKey(0x01, debugName: 'key1');
+      const PhysicalKeyboardKey key2 = PhysicalKeyboardKey(0x01, debugName: 'key2');
+      expect(key1, equals(key1));
+      expect(key1, equals(key2));
     });
   });
   group(LogicalKeyboardKey, () {
@@ -47,6 +44,12 @@ void main() {
       expect(LogicalKeyboardKey.isControlCharacter('~'), isFalse);
       expect(LogicalKeyboardKey.isControlCharacter('\xa0'), isFalse); // NO-BREAK SPACE
     });
+    test('Equality is only based on ID.', () async {
+      const LogicalKeyboardKey key1 = LogicalKeyboardKey(0x01, keyLabel: 'label1', debugName: 'key1');
+      const LogicalKeyboardKey key2 = LogicalKeyboardKey(0x01, keyLabel: 'label2', debugName: 'key2');
+      expect(key1, equals(key1));
+      expect(key1, equals(key2));
+    });
     test('Basic synonyms can be looked up.', () async {
       expect(LogicalKeyboardKey.shiftLeft.synonyms.first, equals(LogicalKeyboardKey.shift));
       expect(LogicalKeyboardKey.controlLeft.synonyms.first, equals(LogicalKeyboardKey.control));
@@ -103,29 +106,5 @@ void main() {
             LogicalKeyboardKey.meta,
           }));
     });
-    test('Values are cached', () async {
-      expect(identical(LogicalKeyboardKey.keyA, LogicalKeyboardKey(LogicalKeyboardKey.keyA.keyId)), true);
-      expect(identical(LogicalKeyboardKey(0x12345), LogicalKeyboardKey(0x12345)), true);
-    });
-    test('keyLabel', () async {
-      expect(LogicalKeyboardKey.keyA.keyLabel, 'A');
-      expect(LogicalKeyboardKey.backslash.keyLabel, r'\');
-      expect(LogicalKeyboardKey(0xD9).keyLabel, 'Ù');
-      expect(LogicalKeyboardKey(0xF9).keyLabel, 'Ù');
-      expect(LogicalKeyboardKey.shiftLeft.keyLabel, 'Shift Left');
-      expect(LogicalKeyboardKey.numpadDecimal.keyLabel, 'Numpad Decimal');
-      expect(LogicalKeyboardKey.numpad1.keyLabel, 'Numpad 1');
-      expect(LogicalKeyboardKey.delete.keyLabel, 'Delete');
-      expect(LogicalKeyboardKey.f12.keyLabel, 'F12');
-      expect(LogicalKeyboardKey.mediaPlay.keyLabel, 'Media Play');
-      expect(LogicalKeyboardKey(0x100012345).keyLabel, '');
-    });
-    test('debugName', () async {
-      expect(LogicalKeyboardKey.keyA.debugName, 'Key A');
-      expect(LogicalKeyboardKey.backslash.debugName, 'Backslash');
-      expect(LogicalKeyboardKey(0xD9).debugName, 'Key Ù');
-      expect(LogicalKeyboardKey.mediaPlay.debugName, 'Media Play');
-      expect(LogicalKeyboardKey(0x100012345).debugName, 'Key with ID 0x00100012345');
-    });
   });
 }

packages/flutter/test/services/raw_keyboard_test.dart

@@ -1178,6 +1178,7 @@ void main() {
       final RawKeyEventDataMacOs data = leftArrowKey.data as RawKeyEventDataMacOs;
       expect(data.physicalKey, equals(PhysicalKeyboardKey.arrowLeft));
       expect(data.logicalKey, equals(LogicalKeyboardKey.arrowLeft));
+      expect(data.logicalKey.keyLabel, isEmpty);
     }, skip: isBrowser); // https://github.com/flutter/flutter/issues/35347
   }, skip: isBrowser); // This is a macOS-specific group.
 
@@ -1323,6 +1324,7 @@ void main() {
       final RawKeyEventDataIos data = leftArrowKey.data as RawKeyEventDataIos;
       expect(data.physicalKey, equals(PhysicalKeyboardKey.arrowLeft));
       expect(data.logicalKey, equals(LogicalKeyboardKey.arrowLeft));
+      expect(data.logicalKey.keyLabel, isEmpty);
     }, skip: isBrowser); // https://github.com/flutter/flutter/issues/35347
   }, skip: isBrowser); // This is an iOS-specific group.
 
@@ -1467,6 +1469,7 @@ void main() {
       final RawKeyEventDataWindows data = leftArrowKey.data as RawKeyEventDataWindows;
       expect(data.physicalKey, equals(PhysicalKeyboardKey.arrowLeft));
       expect(data.logicalKey, equals(LogicalKeyboardKey.arrowLeft));
+      expect(data.logicalKey.keyLabel, isEmpty);
     });
     testWidgets('Win32 VK_PROCESSKEY events are skipped', (WidgetTester tester) async {
       const  String platform = 'windows';

packages/flutter/test/widgets/shortcuts_test.dart

@@ -68,7 +68,7 @@ void main() {
         LogicalKeyboardKey.keyC,
         LogicalKeyboardKey.keyD,
       );
-      final LogicalKeySet setFromSet = LogicalKeySet.fromSet(const <LogicalKeyboardKey>{
+      final LogicalKeySet setFromSet = LogicalKeySet.fromSet(<LogicalKeyboardKey>{
         LogicalKeyboardKey.keyA,
         LogicalKeyboardKey.keyB,
         LogicalKeyboardKey.keyC,
@@ -123,7 +123,7 @@ void main() {
         LogicalKeyboardKey.keyB,
         LogicalKeyboardKey.keyA,
       );
-      final LogicalKeySet set4 = LogicalKeySet.fromSet(const <LogicalKeyboardKey>{
+      final LogicalKeySet set4 = LogicalKeySet.fromSet(<LogicalKeyboardKey>{
         LogicalKeyboardKey.keyD,
         LogicalKeyboardKey.keyC,
         LogicalKeyboardKey.keyB,
@@ -138,7 +138,7 @@ void main() {
       expect(map.containsKey(LogicalKeySet(LogicalKeyboardKey.keyA)), isTrue);
       expect(
           set2,
-          equals(LogicalKeySet.fromSet(const <LogicalKeyboardKey>{
+          equals(LogicalKeySet.fromSet(<LogicalKeyboardKey>{
             LogicalKeyboardKey.keyA,
             LogicalKeyboardKey.keyB,
             LogicalKeyboardKey.keyC,

packages/flutter_test/lib/src/event_simulation.dart

@@ -13,13 +13,6 @@ import 'test_async_utils.dart';
 // https://github.com/flutter/flutter/issues/33521
 // This code can only simulate keys which appear in the key maps.
 
-String _keyLabel(LogicalKeyboardKey key) {
-  final String keyLabel = key.keyLabel;
-  if (keyLabel.length == 1)
-    return keyLabel.toLowerCase();
-  return '';
-}
-
 /// A class that serves as a namespace for a bunch of keyboard-key generation
 /// utilities.
 class KeyEventSimulator {
@@ -213,7 +206,7 @@ class KeyEventSimulator {
 
     if (kIsWeb) {
       result['code'] = _getWebKeyCode(key);
-      result['key'] = _keyLabel(key);
+      result['key'] = key.keyLabel;
       result['metaState'] = _getWebModifierFlags(key, isDown);
       return result;
     }
@@ -221,17 +214,17 @@ class KeyEventSimulator {
     switch (platform) {
       case 'android':
         result['keyCode'] = keyCode;
-        if (_keyLabel(key).isNotEmpty) {
-          result['codePoint'] = _keyLabel(key).codeUnitAt(0);
-          result['character'] = _keyLabel(key);
+        if (key.keyLabel.isNotEmpty) {
+          result['codePoint'] = key.keyLabel.codeUnitAt(0);
+          result['character'] = key.keyLabel;
         }
         result['scanCode'] = scanCode;
         result['metaState'] = _getAndroidModifierFlags(key, isDown);
         break;
       case 'fuchsia':
         result['hidUsage'] = physicalKey.usbHidUsage;
-        if (_keyLabel(key).isNotEmpty) {
-          result['codePoint'] = _keyLabel(key).codeUnitAt(0);
+        if (key.keyLabel.isNotEmpty) {
+          result['codePoint'] = key.keyLabel.codeUnitAt(0);
         }
         result['modifiers'] = _getFuchsiaModifierFlags(key, isDown);
         break;
@@ -240,32 +233,32 @@ class KeyEventSimulator {
         result['keyCode'] = keyCode;
         result['scanCode'] = scanCode;
         result['modifiers'] = _getGlfwModifierFlags(key, isDown);
-        result['unicodeScalarValues'] = _keyLabel(key).isNotEmpty ? _keyLabel(key).codeUnitAt(0) : 0;
+        result['unicodeScalarValues'] = key.keyLabel.isNotEmpty ? key.keyLabel.codeUnitAt(0) : 0;
         break;
       case 'macos':
         result['keyCode'] = scanCode;
-        if (_keyLabel(key).isNotEmpty) {
-          result['characters'] = _keyLabel(key);
-          result['charactersIgnoringModifiers'] = _keyLabel(key);
+        if (key.keyLabel.isNotEmpty) {
+          result['characters'] = key.keyLabel;
+          result['charactersIgnoringModifiers'] = key.keyLabel;
         }
         result['modifiers'] = _getMacOsModifierFlags(key, isDown);
         break;
       case 'ios':
         result['keyCode'] = scanCode;
-        result['characters'] = _keyLabel(key);
-        result['charactersIgnoringModifiers'] = _keyLabel(key);
+        result['characters'] = key.keyLabel;
+        result['charactersIgnoringModifiers'] = key.keyLabel;
         result['modifiers'] = _getIOSModifierFlags(key, isDown);
         break;
       case 'web':
         result['code'] = _getWebKeyCode(key);
-        result['key'] = _keyLabel(key);
+        result['key'] = key.keyLabel;
         result['metaState'] = _getWebModifierFlags(key, isDown);
         break;
       case 'windows':
         result['keyCode'] = keyCode;
         result['scanCode'] = scanCode;
-        if (_keyLabel(key).isNotEmpty) {
-          result['characterCodePoint'] = _keyLabel(key).codeUnitAt(0);
+        if (key.keyLabel.isNotEmpty) {
+          result['characterCodePoint'] = key.keyLabel.codeUnitAt(0);
         }
         result['modifiers'] = _getWindowsModifierFlags(key, isDown);
     }