| // Copyright 2013 The Flutter Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "flutter/shell/platform/windows/keyboard_key_embedder_handler.h" | |
| #include <assert.h> | |
| #include <windows.h> | |
| #include <chrono> | |
| #include <iostream> | |
| #include <string> | |
| #include "flutter/shell/platform/windows/keyboard_utils.h" | |
| namespace flutter { | |
| namespace { | |
| // An arbitrary size for the character cache in bytes. | |
| // | |
| // It should hold a UTF-32 character encoded in UTF-8 as well as the trailing | |
| // '\0'. | |
| constexpr size_t kCharacterCacheSize = 8; | |
| constexpr SHORT kStateMaskToggled = 0x01; | |
| constexpr SHORT kStateMaskPressed = 0x80; | |
| const char* empty_character = ""; | |
| // Get some bits of the char, from the start'th bit from the right (excluded) | |
| // to the end'th bit from the right (included). | |
| // | |
| // For example, _GetBit(0x1234, 8, 4) => 0x3. | |
| char _GetBit(char32_t ch, size_t start, size_t end) { | |
| return (ch >> end) & ((1 << (start - end)) - 1); | |
| } | |
| } // namespace | |
| std::string ConvertChar32ToUtf8(char32_t ch) { | |
| std::string result; | |
| assert(0 <= ch && ch <= 0x10FFFF); | |
| if (ch <= 0x007F) { | |
| result.push_back(ch); | |
| } else if (ch <= 0x07FF) { | |
| result.push_back(0b11000000 + _GetBit(ch, 11, 6)); | |
| result.push_back(0b10000000 + _GetBit(ch, 6, 0)); | |
| } else if (ch <= 0xFFFF) { | |
| result.push_back(0b11100000 + _GetBit(ch, 16, 12)); | |
| result.push_back(0b10000000 + _GetBit(ch, 12, 6)); | |
| result.push_back(0b10000000 + _GetBit(ch, 6, 0)); | |
| } else { | |
| result.push_back(0b11110000 + _GetBit(ch, 21, 18)); | |
| result.push_back(0b10000000 + _GetBit(ch, 18, 12)); | |
| result.push_back(0b10000000 + _GetBit(ch, 12, 6)); | |
| result.push_back(0b10000000 + _GetBit(ch, 6, 0)); | |
| } | |
| return result; | |
| } | |
| KeyboardKeyEmbedderHandler::KeyboardKeyEmbedderHandler( | |
| SendEventHandler send_event, | |
| GetKeyStateHandler get_key_state, | |
| MapVirtualKeyToScanCode map_virtual_key_to_scan_code) | |
| : perform_send_event_(send_event), | |
| get_key_state_(get_key_state), | |
| response_id_(1) { | |
| InitCriticalKeys(map_virtual_key_to_scan_code); | |
| } | |
| KeyboardKeyEmbedderHandler::~KeyboardKeyEmbedderHandler() = default; | |
| static bool isEasciiPrintable(int codeUnit) { | |
| return (codeUnit <= 0x7f && codeUnit >= 0x20) || | |
| (codeUnit <= 0xff && codeUnit >= 0x80); | |
| } | |
| // Converts upper letters to lower letters in ASCII and extended ASCII, and | |
| // returns as-is otherwise. | |
| // | |
| // Independent of locale. | |
| static uint64_t toLower(uint64_t n) { | |
| constexpr uint64_t lower_a = 0x61; | |
| constexpr uint64_t upper_a = 0x41; | |
| constexpr uint64_t upper_z = 0x5a; | |
| constexpr uint64_t lower_a_grave = 0xe0; | |
| constexpr uint64_t upper_a_grave = 0xc0; | |
| constexpr uint64_t upper_thorn = 0xde; | |
| constexpr uint64_t division = 0xf7; | |
| // ASCII range. | |
| if (n >= upper_a && n <= upper_z) { | |
| return n - upper_a + lower_a; | |
| } | |
| // EASCII range. | |
| if (n >= upper_a_grave && n <= upper_thorn && n != division) { | |
| return n - upper_a_grave + lower_a_grave; | |
| } | |
| return n; | |
| } | |
| // Transform scancodes sent by windows to scancodes written in Chromium spec. | |
| static uint16_t normalizeScancode(int windowsScanCode, bool extended) { | |
| // In Chromium spec the extended bit is shown as 0xe000 bit, | |
| // e.g. PageUp is represented as 0xe049. | |
| return (windowsScanCode & 0xff) | (extended ? 0xe000 : 0); | |
| } | |
| uint64_t KeyboardKeyEmbedderHandler::ApplyPlaneToId(uint64_t id, | |
| uint64_t plane) { | |
| return (id & valueMask) | plane; | |
| } | |
| uint64_t KeyboardKeyEmbedderHandler::GetPhysicalKey(int scancode, | |
| bool extended) { | |
| int chromiumScancode = normalizeScancode(scancode, extended); | |
| auto resultIt = windowsToPhysicalMap_.find(chromiumScancode); | |
| if (resultIt != windowsToPhysicalMap_.end()) | |
| return resultIt->second; | |
| return ApplyPlaneToId(scancode, windowsPlane); | |
| } | |
| uint64_t KeyboardKeyEmbedderHandler::GetLogicalKey(int key, | |
| bool extended, | |
| int scancode) { | |
| if (key == VK_PROCESSKEY) { | |
| return VK_PROCESSKEY; | |
| } | |
| // Normally logical keys should only be derived from key codes, but since some | |
| // key codes are either 0 or ambiguous (multiple keys using the same key | |
| // code), these keys are resolved by scan codes. | |
| auto numpadIter = | |
| scanCodeToLogicalMap_.find(normalizeScancode(scancode, extended)); | |
| if (numpadIter != scanCodeToLogicalMap_.cend()) | |
| return numpadIter->second; | |
| // Check if the keyCode is one we know about and have a mapping for. | |
| auto logicalIt = windowsToLogicalMap_.find(key); | |
| if (logicalIt != windowsToLogicalMap_.cend()) | |
| return logicalIt->second; | |
| // Upper case letters should be normalized into lower case letters. | |
| if (isEasciiPrintable(key)) { | |
| return ApplyPlaneToId(toLower(key), unicodePlane); | |
| } | |
| return ApplyPlaneToId(toLower(key), windowsPlane); | |
| } | |
| void KeyboardKeyEmbedderHandler::KeyboardHookImpl( | |
| int key, | |
| int scancode, | |
| int action, | |
| char32_t character, | |
| bool extended, | |
| bool was_down, | |
| std::function<void(bool)> callback) { | |
| const uint64_t physical_key = GetPhysicalKey(scancode, extended); | |
| const uint64_t logical_key = GetLogicalKey(key, extended, scancode); | |
| assert(action == WM_KEYDOWN || action == WM_KEYUP || | |
| action == WM_SYSKEYDOWN || action == WM_SYSKEYUP); | |
| auto last_logical_record_iter = pressingRecords_.find(physical_key); | |
| bool had_record = last_logical_record_iter != pressingRecords_.end(); | |
| uint64_t last_logical_record = | |
| had_record ? last_logical_record_iter->second : 0; | |
| // The logical key for the current "tap sequence". | |
| // | |
| // Key events are formed in tap sequences: down, repeats, up. The logical key | |
| // stays consistent throughout a tap sequence, which is this value. | |
| uint64_t sequence_logical_key = | |
| had_record ? last_logical_record : logical_key; | |
| if (sequence_logical_key == VK_PROCESSKEY) { | |
| // VK_PROCESSKEY means that the key press is used by an IME. These key | |
| // presses are considered handled and not sent to Flutter. These events must | |
| // be filtered by result_logical_key because the key up event of such | |
| // presses uses the "original" logical key. | |
| callback(true); | |
| return; | |
| } | |
| const bool is_event_down = action == WM_KEYDOWN || action == WM_SYSKEYDOWN; | |
| bool event_key_can_be_repeat = true; | |
| UpdateLastSeenCritialKey(key, physical_key, sequence_logical_key); | |
| // Synchronize the toggled states of critical keys (such as whether CapsLocks | |
| // is enabled). Toggled states can only be changed upon a down event, so if | |
| // the recorded toggled state does not match the true state, this function | |
| // will synthesize (an up event if the key is recorded pressed, then) a down | |
| // event. | |
| // | |
| // After this function, all critical keys will have their toggled state | |
| // updated to the true state, while the critical keys whose toggled state have | |
| // been changed will be pressed regardless of their true pressed state. | |
| // Updating the pressed state will be done by SynchronizeCritialPressedStates. | |
| SynchronizeCritialToggledStates(key, is_event_down, &event_key_can_be_repeat); | |
| // Synchronize the pressed states of critical keys (such as whether CapsLocks | |
| // is pressed). | |
| // | |
| // After this function, all critical keys except for the target key will have | |
| // their toggled state and pressed state matched with their true states. The | |
| // target key's pressed state will be updated immediately after this. | |
| SynchronizeCritialPressedStates(key, physical_key, is_event_down, | |
| event_key_can_be_repeat); | |
| // Reassess the last logical record in case pressingRecords_ was modified | |
| // by the above synchronization methods. | |
| last_logical_record_iter = pressingRecords_.find(physical_key); | |
| had_record = last_logical_record_iter != pressingRecords_.end(); | |
| last_logical_record = had_record ? last_logical_record_iter->second : 0; | |
| // The resulting event's `type`. | |
| FlutterKeyEventType type; | |
| character = UndeadChar(character); | |
| char character_bytes[kCharacterCacheSize]; | |
| // What pressingRecords_[physical_key] should be after the KeyboardHookImpl | |
| // returns (0 if the entry should be removed). | |
| uint64_t eventual_logical_record; | |
| uint64_t result_logical_key; | |
| if (is_event_down) { | |
| if (had_record) { | |
| if (was_down) { | |
| // A normal repeated key. | |
| type = kFlutterKeyEventTypeRepeat; | |
| assert(had_record); | |
| ConvertUtf32ToUtf8_(character_bytes, character); | |
| eventual_logical_record = last_logical_record; | |
| result_logical_key = last_logical_record; | |
| } else { | |
| // A non-repeated key has been pressed that has the exact physical key | |
| // as a currently pressed one, usually indicating multiple keyboards are | |
| // pressing keys with the same physical key, or the up event was lost | |
| // during a loss of focus. The down event is ignored. | |
| callback(true); | |
| return; | |
| } | |
| } else { | |
| // A normal down event (whether the system event is a repeat or not). | |
| type = kFlutterKeyEventTypeDown; | |
| assert(!had_record); | |
| ConvertUtf32ToUtf8_(character_bytes, character); | |
| eventual_logical_record = logical_key; | |
| result_logical_key = logical_key; | |
| } | |
| } else { // isPhysicalDown is false | |
| if (last_logical_record == 0) { | |
| // The physical key has been released before. It might indicate a missed | |
| // event due to loss of focus, or multiple keyboards pressed keys with the | |
| // same physical key. Ignore the up event. | |
| callback(true); | |
| return; | |
| } else { | |
| // A normal up event. | |
| type = kFlutterKeyEventTypeUp; | |
| assert(had_record); | |
| // Up events never have character. | |
| character_bytes[0] = '\0'; | |
| eventual_logical_record = 0; | |
| result_logical_key = last_logical_record; | |
| } | |
| } | |
| if (eventual_logical_record != 0) { | |
| pressingRecords_[physical_key] = eventual_logical_record; | |
| } else { | |
| auto record_iter = pressingRecords_.find(physical_key); | |
| // Assert this in debug mode. But in cases that it doesn't satisfy | |
| // (such as due to a bug), make sure the `erase` is only called | |
| // with a valid value to avoid crashing. | |
| if (record_iter != pressingRecords_.end()) { | |
| pressingRecords_.erase(record_iter); | |
| } else { | |
| assert(false); | |
| } | |
| } | |
| FlutterKeyEvent key_data{ | |
| .struct_size = sizeof(FlutterKeyEvent), | |
| .timestamp = static_cast<double>( | |
| std::chrono::duration_cast<std::chrono::microseconds>( | |
| std::chrono::high_resolution_clock::now().time_since_epoch()) | |
| .count()), | |
| .type = type, | |
| .physical = physical_key, | |
| .logical = result_logical_key, | |
| .character = character_bytes, | |
| .synthesized = false, | |
| }; | |
| response_id_ += 1; | |
| uint64_t response_id = response_id_; | |
| PendingResponse pending{ | |
| .callback = | |
| [this, callback = std::move(callback)](bool handled, | |
| uint64_t response_id) { | |
| auto found = pending_responses_.find(response_id); | |
| if (found != pending_responses_.end()) { | |
| pending_responses_.erase(found); | |
| } | |
| callback(handled); | |
| }, | |
| .response_id = response_id, | |
| }; | |
| auto pending_ptr = std::make_unique<PendingResponse>(std::move(pending)); | |
| pending_responses_[response_id] = std::move(pending_ptr); | |
| SendEvent(key_data, KeyboardKeyEmbedderHandler::HandleResponse, | |
| reinterpret_cast<void*>(pending_responses_[response_id].get())); | |
| // Post-event synchronization. It is useful in cases where the true pressing | |
| // state does not match the event type. For example, a CapsLock down event is | |
| // received despite that GetKeyState says that CapsLock is not pressed. In | |
| // such case, post-event synchronization will synthesize a CapsLock up event | |
| // after the main event. | |
| SynchronizeCritialPressedStates(key, physical_key, is_event_down, | |
| event_key_can_be_repeat); | |
| } | |
| void KeyboardKeyEmbedderHandler::KeyboardHook( | |
| int key, | |
| int scancode, | |
| int action, | |
| char32_t character, | |
| bool extended, | |
| bool was_down, | |
| std::function<void(bool)> callback) { | |
| sent_any_events = false; | |
| KeyboardHookImpl(key, scancode, action, character, extended, was_down, | |
| std::move(callback)); | |
| if (!sent_any_events) { | |
| FlutterKeyEvent empty_event{ | |
| .struct_size = sizeof(FlutterKeyEvent), | |
| .timestamp = static_cast<double>( | |
| std::chrono::duration_cast<std::chrono::microseconds>( | |
| std::chrono::high_resolution_clock::now().time_since_epoch()) | |
| .count()), | |
| .type = kFlutterKeyEventTypeDown, | |
| .physical = 0, | |
| .logical = 0, | |
| .character = empty_character, | |
| .synthesized = false, | |
| }; | |
| SendEvent(empty_event, nullptr, nullptr); | |
| } | |
| } | |
| void KeyboardKeyEmbedderHandler::UpdateLastSeenCritialKey( | |
| int virtual_key, | |
| uint64_t physical_key, | |
| uint64_t logical_key) { | |
| auto found = critical_keys_.find(virtual_key); | |
| if (found != critical_keys_.end()) { | |
| found->second.physical_key = physical_key; | |
| found->second.logical_key = logical_key; | |
| } | |
| } | |
| void KeyboardKeyEmbedderHandler::SynchronizeCritialToggledStates( | |
| int event_virtual_key, | |
| bool is_event_down, | |
| bool* event_key_can_be_repeat) { | |
| // NowState ----------------> PreEventState --------------> TrueState | |
| // Synchronization Event | |
| for (auto& kv : critical_keys_) { | |
| UINT virtual_key = kv.first; | |
| CriticalKey& key_info = kv.second; | |
| if (key_info.physical_key == 0) { | |
| // Never seen this key. | |
| continue; | |
| } | |
| assert(key_info.logical_key != 0); | |
| // Check toggling state first, because it might alter pressing state. | |
| if (key_info.check_toggled) { | |
| const bool target_is_pressed = | |
| pressingRecords_.find(key_info.physical_key) != | |
| pressingRecords_.end(); | |
| // The togglable keys observe a 4-phase cycle: | |
| // | |
| // Phase# 0 1 2 3 | |
| // Event Down Up Down Up | |
| // Pressed 0 1 0 1 | |
| // Toggled 0 1 1 0 | |
| const bool true_toggled = get_key_state_(virtual_key) & kStateMaskToggled; | |
| bool pre_event_toggled = true_toggled; | |
| // Check if the main event's key is the key being checked. If it's the | |
| // non-repeat down event, toggle the state. | |
| if (virtual_key == event_virtual_key && !target_is_pressed && | |
| is_event_down) { | |
| pre_event_toggled = !pre_event_toggled; | |
| } | |
| if (key_info.toggled_on != pre_event_toggled) { | |
| // If the key is pressed, release it first. | |
| if (target_is_pressed) { | |
| SendEvent(SynthesizeSimpleEvent( | |
| kFlutterKeyEventTypeUp, key_info.physical_key, | |
| key_info.logical_key, empty_character), | |
| nullptr, nullptr); | |
| } | |
| // Synchronizing toggle state always ends with the key being pressed. | |
| pressingRecords_[key_info.physical_key] = key_info.logical_key; | |
| SendEvent(SynthesizeSimpleEvent(kFlutterKeyEventTypeDown, | |
| key_info.physical_key, | |
| key_info.logical_key, empty_character), | |
| nullptr, nullptr); | |
| *event_key_can_be_repeat = false; | |
| } | |
| key_info.toggled_on = true_toggled; | |
| } | |
| } | |
| } | |
| void KeyboardKeyEmbedderHandler::SynchronizeCritialPressedStates( | |
| int event_virtual_key, | |
| int event_physical_key, | |
| bool is_event_down, | |
| bool event_key_can_be_repeat) { | |
| // During an incoming event, there might be a synthesized Flutter event for | |
| // each key of each pressing goal, followed by an eventual main Flutter | |
| // event. | |
| // | |
| // NowState ----------------> PreEventState --------------> TrueState | |
| // Synchronization Event | |
| // | |
| // The goal of the synchronization algorithm is to derive a pre-event state | |
| // that can satisfy the true state (`true_pressed`) after the event, and that | |
| // requires as few synthesized events based on the current state | |
| // (`now_pressed`) as possible. | |
| for (auto& kv : critical_keys_) { | |
| UINT virtual_key = kv.first; | |
| CriticalKey& key_info = kv.second; | |
| if (key_info.physical_key == 0) { | |
| // Never seen this key. | |
| continue; | |
| } | |
| assert(key_info.logical_key != 0); | |
| if (key_info.check_pressed) { | |
| SHORT true_pressed = get_key_state_(virtual_key) & kStateMaskPressed; | |
| auto pressing_record_iter = pressingRecords_.find(key_info.physical_key); | |
| bool now_pressed = pressing_record_iter != pressingRecords_.end(); | |
| bool pre_event_pressed = true_pressed; | |
| // Check if the main event is the key being checked to get the correct | |
| // target state. | |
| if (is_event_down) { | |
| // For down events, this key is the event key if they have the same | |
| // virtual key, because virtual key represents "functionality." | |
| // | |
| // In that case, normally Flutter should synthesize nothing since the | |
| // resulting event can adapt to the current state by dispatching either | |
| // a down or a repeat event. However, in certain cases (when Flutter has | |
| // just synchronized the key's toggling state) the event must not be a | |
| // repeat event. | |
| if (virtual_key == event_virtual_key) { | |
| if (event_key_can_be_repeat) { | |
| continue; | |
| } else { | |
| pre_event_pressed = false; | |
| } | |
| } | |
| } else { | |
| // For up events, this key is the event key if they have the same | |
| // physical key, because it is necessary to ensure that the physical | |
| // key is correctly released. | |
| // | |
| // In that case, although the previous state should be pressed, don't | |
| // synthesize a down event even if it's not. The later code will handle | |
| // such cases by skipping abrupt up events. Obviously don't synthesize | |
| // up events either. | |
| if (event_physical_key == key_info.physical_key) { | |
| continue; | |
| } | |
| } | |
| if (now_pressed != pre_event_pressed) { | |
| if (now_pressed) { | |
| pressingRecords_.erase(pressing_record_iter); | |
| } else { | |
| pressingRecords_[key_info.physical_key] = key_info.logical_key; | |
| } | |
| const char* empty_character = ""; | |
| SendEvent( | |
| SynthesizeSimpleEvent( | |
| now_pressed ? kFlutterKeyEventTypeUp : kFlutterKeyEventTypeDown, | |
| key_info.physical_key, key_info.logical_key, empty_character), | |
| nullptr, nullptr); | |
| } | |
| } | |
| } | |
| } | |
| void KeyboardKeyEmbedderHandler::HandleResponse(bool handled, void* user_data) { | |
| PendingResponse* pending = reinterpret_cast<PendingResponse*>(user_data); | |
| auto callback = std::move(pending->callback); | |
| callback(handled, pending->response_id); | |
| } | |
| void KeyboardKeyEmbedderHandler::InitCriticalKeys( | |
| MapVirtualKeyToScanCode map_virtual_key_to_scan_code) { | |
| auto createCheckedKey = [this, &map_virtual_key_to_scan_code]( | |
| UINT virtual_key, bool extended, | |
| bool check_pressed, | |
| bool check_toggled) -> CriticalKey { | |
| UINT scan_code = map_virtual_key_to_scan_code(virtual_key, extended); | |
| return CriticalKey{ | |
| .physical_key = GetPhysicalKey(scan_code, extended), | |
| .logical_key = GetLogicalKey(virtual_key, extended, scan_code), | |
| .check_pressed = check_pressed || check_toggled, | |
| .check_toggled = check_toggled, | |
| .toggled_on = check_toggled | |
| ? !!(get_key_state_(virtual_key) & kStateMaskToggled) | |
| : false, | |
| }; | |
| }; | |
| // TODO(dkwingsmt): Consider adding more critical keys here. | |
| // https://github.com/flutter/flutter/issues/76736 | |
| critical_keys_.emplace(VK_LSHIFT, | |
| createCheckedKey(VK_LSHIFT, false, true, false)); | |
| critical_keys_.emplace(VK_RSHIFT, | |
| createCheckedKey(VK_RSHIFT, false, true, false)); | |
| critical_keys_.emplace(VK_LCONTROL, | |
| createCheckedKey(VK_LCONTROL, false, true, false)); | |
| critical_keys_.emplace(VK_RCONTROL, | |
| createCheckedKey(VK_RCONTROL, true, true, false)); | |
| critical_keys_.emplace(VK_LMENU, | |
| createCheckedKey(VK_LMENU, false, true, false)); | |
| critical_keys_.emplace(VK_RMENU, | |
| createCheckedKey(VK_RMENU, true, true, false)); | |
| critical_keys_.emplace(VK_LWIN, createCheckedKey(VK_LWIN, true, true, false)); | |
| critical_keys_.emplace(VK_RWIN, createCheckedKey(VK_RWIN, true, true, false)); | |
| critical_keys_.emplace(VK_CAPITAL, | |
| createCheckedKey(VK_CAPITAL, false, true, true)); | |
| critical_keys_.emplace(VK_SCROLL, | |
| createCheckedKey(VK_SCROLL, false, true, true)); | |
| critical_keys_.emplace(VK_NUMLOCK, | |
| createCheckedKey(VK_NUMLOCK, true, true, true)); | |
| } | |
| void KeyboardKeyEmbedderHandler::ConvertUtf32ToUtf8_(char* out, char32_t ch) { | |
| if (ch == 0) { | |
| out[0] = '\0'; | |
| return; | |
| } | |
| std::string result = ConvertChar32ToUtf8(ch); | |
| strcpy_s(out, kCharacterCacheSize, result.c_str()); | |
| } | |
| FlutterKeyEvent KeyboardKeyEmbedderHandler::SynthesizeSimpleEvent( | |
| FlutterKeyEventType type, | |
| uint64_t physical, | |
| uint64_t logical, | |
| const char* character) { | |
| return FlutterKeyEvent{ | |
| .struct_size = sizeof(FlutterKeyEvent), | |
| .timestamp = static_cast<double>( | |
| std::chrono::duration_cast<std::chrono::microseconds>( | |
| std::chrono::high_resolution_clock::now().time_since_epoch()) | |
| .count()), | |
| .type = type, | |
| .physical = physical, | |
| .logical = logical, | |
| .character = character, | |
| .synthesized = true, | |
| }; | |
| } | |
| void KeyboardKeyEmbedderHandler::SendEvent(const FlutterKeyEvent& event, | |
| FlutterKeyEventCallback callback, | |
| void* user_data) { | |
| sent_any_events = true; | |
| perform_send_event_(event, callback, user_data); | |
| } | |
| } // namespace flutter |