gen_keycodes.dart 11.3 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5 6 7 8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:convert';
import 'dart:io' hide Platform;

import 'package:args/args.dart';
9 10 11
import 'package:gen_keycodes/android_code_gen.dart';
import 'package:gen_keycodes/base_code_gen.dart';
import 'package:gen_keycodes/gtk_code_gen.dart';
12
import 'package:gen_keycodes/ios_code_gen.dart';
13 14 15
import 'package:gen_keycodes/keyboard_keys_code_gen.dart';
import 'package:gen_keycodes/keyboard_maps_code_gen.dart';
import 'package:gen_keycodes/logical_key_data.dart';
16 17
import 'package:gen_keycodes/macos_code_gen.dart';
import 'package:gen_keycodes/physical_key_data.dart';
18 19
import 'package:gen_keycodes/testing_key_codes_cc_gen.dart';
import 'package:gen_keycodes/testing_key_codes_java_gen.dart';
20
import 'package:gen_keycodes/utils.dart';
21 22
import 'package:gen_keycodes/web_code_gen.dart';
import 'package:gen_keycodes/windows_code_gen.dart';
23 24
import 'package:http/http.dart' as http;
import 'package:path/path.dart' as path;
25

26
/// Get contents of the file that contains the physical key mapping in Chromium
27
/// source.
28
Future<String> getChromiumCodes() async {
29 30
  final Uri keyCodesUri = Uri.parse('https://chromium.googlesource.com/codesearch/chromium/src/+/refs/heads/master/ui/events/keycodes/dom/dom_code_data.inc?format=TEXT');
  return utf8.decode(base64.decode(await http.read(keyCodesUri)));
31 32
}

33 34 35 36 37 38 39
/// Get contents of the file that contains the logical key mapping in Chromium
/// source.
Future<String> getChromiumKeys() async {
  final Uri keyCodesUri = Uri.parse('https://chromium.googlesource.com/codesearch/chromium/src/+/refs/heads/master/ui/events/keycodes/dom/dom_key_data.inc?format=TEXT');
  return utf8.decode(base64.decode(await http.read(keyCodesUri)));
}

40 41 42 43 44 45
/// Get contents of the file that contains the key codes in Android source.
Future<String> getAndroidKeyCodes() async {
  final Uri keyCodesUri = Uri.parse('https://android.googlesource.com/platform/frameworks/native/+/master/include/android/keycodes.h?format=TEXT');
  return utf8.decode(base64.decode(await http.read(keyCodesUri)));
}

46 47
Future<String> getWindowsKeyCodes() async {
  final Uri keyCodesUri = Uri.parse('https://raw.githubusercontent.com/tpn/winsdk-10/master/Include/10.0.10240.0/um/WinUser.h');
48
  return http.read(keyCodesUri);
49 50
}

51 52 53 54 55 56 57 58 59 60 61
/// Get contents of the file that contains the scan codes in Android source.
/// Yes, this is just the generic keyboard layout file for base Android distro
/// This is because there isn't any facility in Android to get the keyboard
/// layout, so we're using this to match scan codes with symbol names for most
/// common keyboards. Other than some special keyboards and game pads, this
/// should be OK.
Future<String> getAndroidScanCodes() async {
  final Uri scanCodesUri = Uri.parse('https://android.googlesource.com/platform/frameworks/base/+/master/data/keyboards/Generic.kl?format=TEXT');
  return utf8.decode(base64.decode(await http.read(scanCodesUri)));
}

62 63
Future<String> getGlfwKeyCodes() async {
  final Uri keyCodesUri = Uri.parse('https://raw.githubusercontent.com/glfw/glfw/master/include/GLFW/glfw3.h');
64
  return http.read(keyCodesUri);
65 66
}

67
Future<String> getGtkKeyCodes() async {
68
  final Uri keyCodesUri = Uri.parse('https://gitlab.gnome.org/GNOME/gtk/-/raw/gtk-3-24/gdk/gdkkeysyms.h');
69
  return http.read(keyCodesUri);
70 71
}

72 73 74 75
String readDataFile(String fileName) {
  return File(path.join(dataRoot, fileName)).readAsStringSync();
}

76 77 78 79 80 81 82 83 84
bool _assertsEnabled() {
  bool enabledAsserts = false;
  assert(() {
    enabledAsserts = true;
    return true;
  }());
  return enabledAsserts;
}

85 86 87 88 89 90 91 92 93
Future<void> generate(String name, String outDir, BaseCodeGenerator generator) {
  final File codeFile = File(outDir);
  if (!codeFile.existsSync()) {
    codeFile.createSync(recursive: true);
  }
  print('Writing ${name.padRight(15)}${codeFile.absolute}');
  return codeFile.writeAsString(generator.generate());
}

94
Future<void> main(List<String> rawArguments) async {
95 96 97 98
  if (!_assertsEnabled()) {
    print('The gen_keycodes script must be run with --enable-asserts.');
    return;
  }
99 100
  final ArgParser argParser = ArgParser();
  argParser.addOption(
101 102 103 104 105 106 107
    'engine-root',
    defaultsTo: path.join(flutterRoot.path, '..', 'engine', 'src', 'flutter'),
    help: 'The path to the root of the flutter/engine repository. This is used '
        'to place the generated engine mapping files. If --engine-root is not '
        r'specified, it will default to $flutterRoot/../engine/src/flutter, '
        'assuming the engine gclient folder is placed at the same folder as '
        'the flutter/flutter repository.',
108
  );
109
  argParser.addOption(
110
    'physical-data',
111
    defaultsTo: path.join(dataRoot, 'physical_key_data.g.json'),
112 113 114 115 116
    help: 'The path to where the physical key data file should be written when '
        'collected, and read from when generating output code. If --physical-data is '
        'not specified, the output will be written to/read from the current '
        "directory. If the output directory doesn't exist, it, and the path to "
        'it, will be created.',
117
  );
118
  argParser.addOption(
119
    'logical-data',
120
    defaultsTo: path.join(dataRoot, 'logical_key_data.g.json'),
121 122
    help: 'The path to where the logical key data file should be written when '
        'collected, and read from when generating output code. If --logical-data is '
123 124 125 126 127 128
        'not specified, the output will be written to/read from the current '
        "directory. If the output directory doesn't exist, it, and the path to "
        'it, will be created.',
  );
  argParser.addOption(
    'code',
129 130
    defaultsTo: path.join(flutterRoot.path, 'packages', 'flutter', 'lib', 'src', 'services', 'keyboard_key.g.dart'),
    help: 'The path to where the output "keyboard_key.g.dart" file should be '
131 132 133 134 135 136
        'written. If --code is not specified, the output will be written to the '
        'correct directory in the flutter tree. If the output directory does not '
        'exist, it, and the path to it, will be created.',
  );
  argParser.addOption(
    'maps',
137 138
    defaultsTo: path.join(flutterRoot.path, 'packages', 'flutter', 'lib', 'src', 'services', 'keyboard_maps.g.dart'),
    help: 'The path to where the output "keyboard_maps.g.dart" file should be '
139 140 141 142 143 144 145 146 147
      'written. If --maps is not specified, the output will be written to the '
      'correct directory in the flutter tree. If the output directory does not '
      'exist, it, and the path to it, will be created.',
  );
  argParser.addFlag(
    'collect',
    negatable: false,
    help: 'If this flag is set, then collect and parse header files from '
        'Chromium and Android instead of reading pre-parsed data from '
148
        '"physical_key_data.g.json" and "logical_key_data.g.json", and then '
149
        'update these files with the fresh data.',
150 151 152 153 154 155 156 157 158
  );
  argParser.addFlag(
    'help',
    negatable: false,
    help: 'Print help for this command.',
  );

  final ArgResults parsedArguments = argParser.parse(rawArguments);

159
  if (parsedArguments['help'] as bool) {
160 161 162 163
    print(argParser.usage);
    exit(0);
  }

164
  PlatformCodeGenerator.engineRoot = parsedArguments['engine-root'] as String;
165

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
  PhysicalKeyData physicalData;
  LogicalKeyData logicalData;
  if (parsedArguments['collect'] as bool) {
    // Physical
    final String baseHidCodes = await getChromiumCodes();
    final String supplementalHidCodes = readDataFile('supplemental_hid_codes.inc');
    final String androidScanCodes = await getAndroidScanCodes();
    final String androidToDomKey = readDataFile('android_key_name_to_name.json');
    physicalData = PhysicalKeyData(
      <String>[baseHidCodes, supplementalHidCodes].join('\n'),
      androidScanCodes,
      androidToDomKey,
    );

    // Logical
    final String gtkKeyCodes = await getGtkKeyCodes();
    final String webLogicalKeys = await getChromiumKeys();
    final String supplementalKeyData = readDataFile('supplemental_key_data.inc');
    final String gtkToDomKey = readDataFile('gtk_logical_name_mapping.json');
    final String windowsKeyCodes = await getWindowsKeyCodes();
    final String windowsToDomKey = readDataFile('windows_logical_to_window_vk.json');
    final String macosLogicalToPhysical = readDataFile('macos_logical_to_physical.json');
    final String iosLogicalToPhysical = readDataFile('ios_logical_to_physical.json');
    final String androidKeyCodes = await getAndroidKeyCodes();
190 191
    final String glfwKeyCodes = await getGlfwKeyCodes();
    final String glfwToDomKey = readDataFile('glfw_key_name_to_name.json');
192 193 194 195 196 197 198 199 200 201 202

    logicalData = LogicalKeyData(
      <String>[webLogicalKeys, supplementalKeyData].join('\n'),
      gtkKeyCodes,
      gtkToDomKey,
      windowsKeyCodes,
      windowsToDomKey,
      androidKeyCodes,
      androidToDomKey,
      macosLogicalToPhysical,
      iosLogicalToPhysical,
203 204
      glfwKeyCodes,
      glfwToDomKey,
205 206 207 208
      physicalData,
    );

    // Write data files
209
    const JsonEncoder encoder = JsonEncoder.withIndent('  ');
210 211 212 213
    final String physicalJson = encoder.convert(physicalData.toJson());
    File(parsedArguments['physical-data'] as String).writeAsStringSync('$physicalJson\n');
    final String logicalJson = encoder.convert(logicalData.toJson());
    File(parsedArguments['logical-data'] as String).writeAsStringSync('$logicalJson\n');
214
  } else {
215 216
    physicalData = PhysicalKeyData.fromJson(json.decode(await File(parsedArguments['physical-data'] as String).readAsString()) as Map<String, dynamic>);
    logicalData = LogicalKeyData.fromJson(json.decode(await File(parsedArguments['logical-data'] as String).readAsString()) as Map<String, dynamic>);
217 218
  }

219 220
  final Map<String, bool> layoutGoals = parseMapOfBool(readDataFile('layout_goals.json'));

221 222 223 224 225 226 227 228
  await generate('key codes',
      parsedArguments['code'] as String,
      KeyboardKeysCodeGenerator(physicalData, logicalData));
  await generate('key maps',
      parsedArguments['maps'] as String,
      KeyboardMapsCodeGenerator(physicalData, logicalData));
  await generate('engine utils',
      path.join(PlatformCodeGenerator.engineRoot,
229
          'shell', 'platform', 'embedder', 'test_utils', 'key_codes.g.h'),
230 231 232 233 234
      KeyCodesCcGenerator(physicalData, logicalData));
  await generate('android utils',
      path.join(PlatformCodeGenerator.engineRoot, 'shell', 'platform',
          path.join('android', 'test', 'io', 'flutter', 'util', 'KeyCodes.java')),
      KeyCodesJavaGenerator(physicalData, logicalData));
235

236 237 238 239 240
  final Map<String, PlatformCodeGenerator> platforms = <String, PlatformCodeGenerator>{
    'android': AndroidCodeGenerator(
      physicalData,
      logicalData,
    ),
241 242 243
    'macos': MacOSCodeGenerator(
      physicalData,
      logicalData,
244
      layoutGoals,
245 246
    ),
    'ios': IOSCodeGenerator(
247 248 249 250 251 252 253 254 255 256 257 258 259
      physicalData,
      logicalData,
    ),
    'windows': WindowsCodeGenerator(
      physicalData,
      logicalData,
      readDataFile('windows_scancode_logical_map.json')
    ),
    'linux': GtkCodeGenerator(
      physicalData,
      logicalData,
      readDataFile('gtk_modifier_bit_mapping.json'),
      readDataFile('gtk_lock_bit_mapping.json'),
260
      layoutGoals,
261 262 263 264 265 266 267 268 269 270
    ),
    'web': WebCodeGenerator(
      physicalData,
      logicalData,
      readDataFile('web_logical_location_mapping.json'),
    ),
  };
  await Future.wait(platforms.entries.map((MapEntry<String, PlatformCodeGenerator> entry) {
    final String platform = entry.key;
    final PlatformCodeGenerator codeGenerator = entry.value;
271 272 273
    return generate('$platform map',
        codeGenerator.outputPath(platform),
        codeGenerator);
274
  }));
275
}