@desklink/host 0.1.0

package/engine/vendor/inputtino/src/uinput/joypad_utils.hpp

@@ -0,0 +1,246 @@
+#pragma once
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+#include <fcntl.h>
+#include <filesystem>
+#include <inputtino/input.hpp>
+#include <inputtino/protected_types.hpp>
+#include <iostream>
+#include <linux/input.h>
+#include <linux/uinput.h>
+#include <optional>
+#include <poll.h>
+#include <thread>
+
+namespace inputtino {
+
+using namespace std::chrono_literals;
+
+constexpr long MAX_GAIN = 0xFFFF;
+constexpr int RUMBLE_POLL_TIMEOUT = 500; // ms
+
+/**
+ * Joypads will also have one `/dev/input/js*` device as child, we want to expose that as well
+ */
+static std::vector<std::string> get_child_dev_nodes(libevdev_uinput *device) {
+  std::vector<std::string> result;
+
+  auto dev_path = libevdev_uinput_get_devnode(device);
+  if (dev_path) {
+    result.push_back(dev_path);
+  }
+
+  auto sys_path = libevdev_uinput_get_syspath(device);
+  if (sys_path) {
+    for (const auto &entry : std::filesystem::directory_iterator(sys_path)) {
+      if (entry.is_directory() && entry.path().filename().string().rfind("js", 0) == 0) { // starts with "js"?
+        result.push_back("/dev/input/" + entry.path().filename().string());
+      }
+    }
+  }
+
+  return result;
+}
+
+struct ActiveRumbleEffect {
+  std::chrono::steady_clock::time_point start_point;
+  std::chrono::steady_clock::time_point end_point;
+  std::chrono::milliseconds length;
+  std::chrono::milliseconds delay;
+  ff_envelope envelope;
+
+  struct {
+    long weak, strong;
+  } start;
+
+  struct {
+    long weak, strong;
+  } end;
+};
+
+static long rumble_magnitude(std::chrono::milliseconds time_left,
+                             std::uint32_t start,
+                             std::uint32_t end,
+                             std::chrono::milliseconds length) {
+  auto rel = end - start;
+  return start + (rel * time_left.count() / length.count());
+}
+
+static std::pair<long, long> simulate_rumble(const ActiveRumbleEffect &effect,
+                                             const std::chrono::steady_clock::time_point &now) {
+  if (effect.end_point < now || now < effect.start_point) {
+    return {0, 0};
+  }
+
+  auto time_left = std::chrono::duration_cast<std::chrono::milliseconds>(effect.end_point - now);
+  auto t = effect.length - time_left;
+
+  auto weak = rumble_magnitude(t, effect.start.weak, effect.end.weak, effect.length);
+  auto strong = rumble_magnitude(t, effect.start.strong, effect.end.strong, effect.length);
+
+  if (t.count() < effect.envelope.attack_length) {
+    weak = (effect.envelope.attack_level * t.count() + weak * (effect.envelope.attack_length - t.count())) /
+           effect.envelope.attack_length;
+    strong = (effect.envelope.attack_level * t.count() + strong * (effect.envelope.attack_length - t.count())) /
+             effect.envelope.attack_length;
+  } else if (time_left.count() < effect.envelope.fade_length) {
+    auto dt = (t - effect.length).count() + effect.envelope.fade_length;
+
+    weak = (effect.envelope.fade_level * dt + weak * (effect.envelope.fade_length - dt)) / effect.envelope.fade_length;
+    strong = (effect.envelope.fade_level * dt + strong * (effect.envelope.fade_length - dt)) /
+             effect.envelope.fade_length;
+  }
+
+  return {weak, strong};
+}
+
+static ActiveRumbleEffect create_rumble_effect(const ff_effect &effect) {
+  // All duration values are expressed in ms. Values above 32767 ms (0x7fff) should not be used
+  ActiveRumbleEffect r_effect{
+      .start_point = std::chrono::steady_clock::time_point::min(),
+      .end_point = std::chrono::steady_clock::time_point::min(),
+      .length = std::chrono::milliseconds{std::clamp(effect.replay.length, (std::uint16_t)0, (std::uint16_t)32767)},
+      .delay = std::chrono::milliseconds{std::clamp(effect.replay.delay, (std::uint16_t)0, (std::uint16_t)32767)},
+      .envelope = {}};
+  switch (effect.type) {
+  case FF_CONSTANT:
+    r_effect.start.weak = effect.u.constant.level;
+    r_effect.start.strong = effect.u.constant.level;
+    r_effect.end.weak = effect.u.constant.level;
+    r_effect.end.strong = effect.u.constant.level;
+    r_effect.envelope = effect.u.constant.envelope;
+    break;
+  case FF_PERIODIC:
+    r_effect.start.weak = effect.u.periodic.magnitude;
+    r_effect.start.strong = effect.u.periodic.magnitude;
+    r_effect.end.weak = effect.u.periodic.magnitude;
+    r_effect.end.strong = effect.u.periodic.magnitude;
+    r_effect.envelope = effect.u.periodic.envelope;
+    break;
+  case FF_RAMP:
+    r_effect.start.weak = effect.u.ramp.start_level;
+    r_effect.start.strong = effect.u.ramp.start_level;
+    r_effect.end.weak = effect.u.ramp.end_level;
+    r_effect.end.strong = effect.u.ramp.end_level;
+    r_effect.envelope = effect.u.ramp.envelope;
+    break;
+  case FF_RUMBLE:
+    r_effect.start.weak = effect.u.rumble.weak_magnitude;
+    r_effect.start.strong = effect.u.rumble.strong_magnitude;
+    r_effect.end.weak = effect.u.rumble.weak_magnitude;
+    r_effect.end.strong = effect.u.rumble.strong_magnitude;
+    break;
+  }
+  return r_effect;
+}
+
+/**
+ * Here we listen for events from the device and call the corresponding callback functions
+ *
+ * Rumble:
+ *   First of, this is called force feedback (FF) in linux,
+ *   you can see some docs here: https://www.kernel.org/doc/html/latest/input/ff.html
+ *   In uinput this works as a two step process:
+ *    - you first upload the FF effect with a given request ID
+ *    - later on when the rumble has been activated you'll receive an EV_FF in your /dev/input/event**
+ *      where the value is the request ID
+ *   You can test the virtual devices that we create by simply using the utility `fftest`
+ */
+static void event_listener(const std::shared_ptr<BaseJoypadState> &state) {
+  std::this_thread::sleep_for(100ms); // We have to sleep in order to be able to read from the newly created device
+
+  auto uinput_fd = libevdev_uinput_get_fd(state->joy.get());
+  if (uinput_fd < 0) {
+    std::cerr << "Unable to open uinput device, additional events will be disabled.";
+    return;
+  }
+
+  // We have to add 0_NONBLOCK to the flags in order to be able to read the events
+  int flags = fcntl(uinput_fd, F_GETFL, 0);
+  fcntl(uinput_fd, F_SETFL, flags | O_NONBLOCK);
+
+  /* Local copy of all the uploaded ff effects */
+  std::map<int, ActiveRumbleEffect> ff_effects = {};
+  std::pair<std::uint32_t, std::uint32_t> prev_rumble = {0, 0};
+
+  /* This can only be set globally when receiving FF_GAIN */
+  unsigned int current_gain = MAX_GAIN;
+
+  std::array<pollfd, 1> pfds = {pollfd{.fd = uinput_fd, .events = POLLIN}};
+  int poll_rs = 0;
+
+  while (!state->stop_listening_events) {
+    poll_rs = poll(pfds.data(), pfds.size(), RUMBLE_POLL_TIMEOUT);
+    if (poll_rs < 0) {
+      std::cerr << "Failed polling uinput fd; ret=" << strerror(errno);
+      return;
+    }
+
+    auto events = fetch_events(uinput_fd);
+    for (auto ev : events) {
+      if (ev->type == EV_UINPUT && ev->code == UI_FF_UPLOAD) { // Upload a new FF effect
+        uinput_ff_upload upload{};
+        upload.request_id = ev->value;
+
+        ioctl(uinput_fd, UI_BEGIN_FF_UPLOAD, &upload); // retrieve the effect
+
+        auto new_effect = create_rumble_effect(upload.effect);
+        if (ff_effects.find(upload.effect.id) != ff_effects.end()) {
+          // We have to keep the original start and end points of the effect
+          new_effect.start_point = ff_effects[upload.effect.id].start_point;
+          new_effect.end_point = ff_effects[upload.effect.id].end_point;
+        }
+        ff_effects.insert_or_assign(upload.effect.id, create_rumble_effect(upload.effect));
+        upload.retval = 0;
+
+        ioctl(uinput_fd, UI_END_FF_UPLOAD, &upload);
+      } else if (ev->type == EV_UINPUT && ev->code == UI_FF_ERASE) { // Remove an uploaded FF effect
+        uinput_ff_erase erase{};
+        erase.request_id = ev->value;
+
+        ioctl(uinput_fd, UI_BEGIN_FF_ERASE, &erase); // retrieve ff_erase
+
+        ff_effects.erase(erase.effect_id);
+        erase.retval = 0;
+
+        ioctl(uinput_fd, UI_END_FF_ERASE, &erase);
+      } else if (ev->type == EV_FF && ev->code == FF_GAIN) { // Force feedback set gain
+        current_gain = std::clamp((long)ev->value, 0l, MAX_GAIN);
+      } else if (ev->type == EV_FF) { // Force feedback effect
+        auto effect_id = ev->code;
+        if (auto effect = ff_effects.find(effect_id); effect != ff_effects.end()) {
+          if (ev->value) { // Activate
+            auto now = std::chrono::steady_clock::now();
+            effect->second.start_point = now + effect->second.delay;
+            effect->second.end_point = now + effect->second.delay + effect->second.length;
+          } else { // Deactivate
+            effect->second.end_point = std::chrono::steady_clock::time_point::min();
+          }
+        }
+      }
+    }
+
+    auto now = std::chrono::steady_clock::now();
+
+    // Accumulate all rumble effects
+    std::pair<long, long> current_rumble = {0, 0};
+    for (auto &[_id, effect] : ff_effects) {
+      auto [weak, strong] = simulate_rumble(effect, now);
+      current_rumble.first += weak;
+      current_rumble.second += strong;
+    }
+    // Avoid sending too many events
+    if (prev_rumble.first != current_rumble.first || prev_rumble.second != current_rumble.second) {
+      prev_rumble.first = current_rumble.first;
+      prev_rumble.second = current_rumble.second;
+
+      if (auto callback = state->on_rumble) {
+        callback.value()(static_cast<int>((current_rumble.second * current_gain / MAX_GAIN)),
+                         static_cast<int>((current_rumble.first * current_gain / MAX_GAIN)));
+      }
+    }
+  }
+}
+
+} // namespace inputtino

package/engine/vendor/inputtino/src/uinput/joypad_xbox.cpp

@@ -0,0 +1,190 @@
+#include "joypad_utils.hpp"
+#include <cstring>
+#include <inputtino/input.hpp>
+#include <inputtino/protected_types.hpp>
+#include <iostream>
+#include <linux/input.h>
+#include <optional>
+#include <thread>
+
+namespace inputtino {
+
+std::vector<std::string> XboxOneJoypad::get_nodes() const {
+  std::vector<std::string> nodes;
+
+  if (auto joy = _state->joy.get()) {
+    auto additional_nodes = get_child_dev_nodes(joy);
+    nodes.insert(nodes.end(), additional_nodes.begin(), additional_nodes.end());
+  }
+
+  return nodes;
+}
+
+Result<libevdev_uinput_ptr> create_xbox_controller(const DeviceDefinition &device) {
+  libevdev *dev = libevdev_new();
+  libevdev_uinput *uidev;
+
+  libevdev_set_name(dev, device.name.c_str());
+  libevdev_set_id_vendor(dev, device.vendor_id);
+  libevdev_set_id_product(dev, device.product_id);
+  libevdev_set_id_version(dev, device.version);
+  libevdev_set_id_bustype(dev, BUS_USB);
+
+  libevdev_enable_event_type(dev, EV_KEY);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_WEST, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_EAST, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_NORTH, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_SOUTH, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_THUMBL, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_THUMBR, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TR, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_TL, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_SELECT, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_MODE, nullptr);
+  libevdev_enable_event_code(dev, EV_KEY, BTN_START, nullptr);
+
+  libevdev_enable_event_type(dev, EV_ABS);
+
+  input_absinfo dpad{0, -1, 1, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_HAT0Y, &dpad);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_HAT0X, &dpad);
+
+  input_absinfo stick{0, -32768, 32767, 16, 128, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_X, &stick);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_RX, &stick);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &stick);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_RY, &stick);
+
+  input_absinfo trigger{0, 0, 255, 0, 0, 0};
+  libevdev_enable_event_code(dev, EV_ABS, ABS_Z, &trigger);
+  libevdev_enable_event_code(dev, EV_ABS, ABS_RZ, &trigger);
+
+  libevdev_enable_event_type(dev, EV_FF);
+  libevdev_enable_event_code(dev, EV_FF, FF_RUMBLE, nullptr);
+  libevdev_enable_event_code(dev, EV_FF, FF_CONSTANT, nullptr);
+  libevdev_enable_event_code(dev, EV_FF, FF_PERIODIC, nullptr);
+  libevdev_enable_event_code(dev, EV_FF, FF_SINE, nullptr);
+  libevdev_enable_event_code(dev, EV_FF, FF_RAMP, nullptr);
+  libevdev_enable_event_code(dev, EV_FF, FF_GAIN, nullptr);
+
+  auto err = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
+  libevdev_free(dev);
+  if (err != 0) {
+    return Error(strerror(-err));
+  }
+
+  return libevdev_uinput_ptr{uidev, ::libevdev_uinput_destroy};
+}
+
+XboxOneJoypad::XboxOneJoypad() : _state(std::make_shared<XboxOneJoypadState>()) {}
+
+XboxOneJoypad::~XboxOneJoypad() {
+  if (_state) {
+    _state->stop_listening_events = true;
+    if (_state->joy.get() != nullptr && _state->events_thread.joinable()) {
+      _state->events_thread.join();
+    }
+  }
+}
+
+Result<XboxOneJoypad> XboxOneJoypad::create(const DeviceDefinition &device) {
+  auto joy_el = create_xbox_controller(device);
+  if (!joy_el) {
+    return Error(joy_el.getErrorMessage());
+  }
+
+  XboxOneJoypad joypad;
+  joypad._state->joy = std::move(*joy_el);
+
+  auto event_thread = std::thread(event_listener, joypad._state);
+  joypad._state->events_thread = std::move(event_thread);
+  joypad._state->events_thread.detach();
+  return joypad;
+}
+
+void XboxOneJoypad::set_pressed_buttons(unsigned int newly_pressed) {
+  // Button flags that have been changed between current and prev
+  auto bf_changed = newly_pressed ^ this->_state->currently_pressed_btns;
+  // Button flags that are only part of the new packet
+  auto bf_new = newly_pressed;
+  if (auto controller = this->_state->joy.get()) {
+
+    if (bf_changed) {
+      if ((DPAD_UP | DPAD_DOWN) & bf_changed) {
+        int button_state = bf_new & DPAD_UP ? -1 : (bf_new & DPAD_DOWN ? 1 : 0);
+
+        libevdev_uinput_write_event(controller, EV_ABS, ABS_HAT0Y, button_state);
+      }
+
+      if ((DPAD_LEFT | DPAD_RIGHT) & bf_changed) {
+        int button_state = bf_new & DPAD_LEFT ? -1 : (bf_new & DPAD_RIGHT ? 1 : 0);
+
+        libevdev_uinput_write_event(controller, EV_ABS, ABS_HAT0X, button_state);
+      }
+
+      if (START & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_START, bf_new & START ? 1 : 0);
+      if (BACK & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_SELECT, bf_new & BACK ? 1 : 0);
+      if (LEFT_STICK & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_THUMBL, bf_new & LEFT_STICK ? 1 : 0);
+      if (RIGHT_STICK & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_THUMBR, bf_new & RIGHT_STICK ? 1 : 0);
+      if (LEFT_BUTTON & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_TL, bf_new & LEFT_BUTTON ? 1 : 0);
+      if (RIGHT_BUTTON & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_TR, bf_new & RIGHT_BUTTON ? 1 : 0);
+      if (HOME & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_MODE, bf_new & HOME ? 1 : 0);
+      if (A & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_SOUTH, bf_new & A ? 1 : 0);
+      if (B & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_EAST, bf_new & B ? 1 : 0);
+      if (X & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_NORTH, bf_new & X ? 1 : 0);
+      if (Y & bf_changed)
+        libevdev_uinput_write_event(controller, EV_KEY, BTN_WEST, bf_new & Y ? 1 : 0);
+    }
+
+    libevdev_uinput_write_event(controller, EV_SYN, SYN_REPORT, 0);
+  }
+  this->_state->currently_pressed_btns = bf_new;
+}
+
+void XboxOneJoypad::set_stick(STICK_POSITION stick_type, short x, short y) {
+  if (auto controller = this->_state->joy.get()) {
+    if (stick_type == LS) {
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_X, x);
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_Y, -y);
+    } else {
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_RX, x);
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_RY, -y);
+    }
+
+    libevdev_uinput_write_event(controller, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void XboxOneJoypad::set_triggers(int16_t left, int16_t right) {
+  if (auto controller = this->_state->joy.get()) {
+    if (left > 0) {
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_Z, left);
+    } else {
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_Z, left);
+    }
+
+    if (right > 0) {
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_RZ, right);
+    } else {
+      libevdev_uinput_write_event(controller, EV_ABS, ABS_RZ, right);
+    }
+
+    libevdev_uinput_write_event(controller, EV_SYN, SYN_REPORT, 0);
+  }
+}
+
+void XboxOneJoypad::set_on_rumble(const std::function<void(int, int)> &callback) {
+  this->_state->on_rumble = callback;
+}
+
+} // namespace inputtino

package/engine/vendor/inputtino/src/uinput/keyboard.cpp

@@ -0,0 +1,120 @@
+#include "inputtino/input.hpp"
+
+#include <algorithm>
+#include <cstring>
+#include <inputtino/protected_types.hpp>
+#include <inputtino/keyboard.hpp>
+#include <thread>
+
+namespace inputtino {
+
+using namespace std::string_literals;
+
+std::vector<std::string> Keyboard::get_nodes() const {
+  std::vector<std::string> nodes;
+
+  if (auto kb = _state->kb.get()) {
+    nodes.emplace_back(libevdev_uinput_get_devnode(kb));
+  }
+
+  return nodes;
+}
+
+Result<libevdev_uinput_ptr> create_keyboard(const DeviceDefinition &device) {
+  auto dev = libevdev_new();
+  libevdev_uinput *uidev;
+
+  libevdev_set_name(dev, device.name.c_str());
+  libevdev_set_id_vendor(dev, device.vendor_id);
+  libevdev_set_id_product(dev, device.product_id);
+  libevdev_set_id_version(dev, device.version);
+  libevdev_set_id_bustype(dev, BUS_USB);
+
+  libevdev_enable_event_type(dev, EV_KEY);
+  libevdev_enable_event_code(dev, EV_KEY, KEY_BACKSPACE, nullptr);
+
+  for (auto ev : keyboard::key_mappings) {
+    libevdev_enable_event_code(dev, EV_KEY, ev.second.linux_code, nullptr);
+  }
+
+  auto err = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
+  libevdev_free(dev);
+  if (err != 0) {
+    return Error(strerror(-err));
+  }
+
+  return libevdev_uinput_ptr{uidev, ::libevdev_uinput_destroy};
+}
+
+static std::optional<keyboard::KEY_MAP> press_btn(libevdev_uinput *kb, short key_code) {
+  auto search_key = keyboard::key_mappings.find(key_code);
+  if (search_key != keyboard::key_mappings.end()) {
+    auto mapped_key = search_key->second;
+
+    libevdev_uinput_write_event(kb, EV_MSC, MSC_SCAN, mapped_key.scan_code);
+    libevdev_uinput_write_event(kb, EV_KEY, mapped_key.linux_code, 1);
+    libevdev_uinput_write_event(kb, EV_SYN, SYN_REPORT, 0);
+    return mapped_key;
+  }
+  return {};
+}
+
+Keyboard::Keyboard() : _state(std::make_shared<KeyboardState>()) {}
+
+Keyboard::~Keyboard() {
+  if (_state) {
+    _state->stop_repeat_thread = true;
+    if (_state->repeat_press_t.joinable()) {
+      _state->repeat_press_t.join();
+    }
+  }
+}
+
+Result<Keyboard> Keyboard::create(const DeviceDefinition &device, int millis_repress_key) {
+  auto kb_el = create_keyboard(device);
+  if (kb_el) {
+    Keyboard kb;
+    kb._state->kb = std::move(*kb_el);
+    auto repeat_thread = std::thread([state = kb._state, millis_repress_key]() {
+      while (!state->stop_repeat_thread) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(millis_repress_key));
+        for (auto key : state->cur_press_keys) {
+          if (auto keyboard = state->kb.get()) {
+            press_btn(keyboard, key);
+          }
+        }
+      }
+    });
+    kb._state->repeat_press_t = std::move(repeat_thread);
+    kb._state->repeat_press_t.detach();
+    return kb;
+  } else {
+    return Error(kb_el.getErrorMessage());
+  }
+}
+
+void Keyboard::press(short key_code) {
+  if (auto keyboard = _state->kb.get()) {
+    if (auto key = press_btn(keyboard, key_code)) {
+      _state->cur_press_keys.push_back(key_code);
+    }
+  }
+}
+
+void Keyboard::release(short key_code) {
+  auto search_key = keyboard::key_mappings.find(key_code);
+  if (search_key != keyboard::key_mappings.end()) {
+    if (auto keyboard = _state->kb.get()) {
+      auto mapped_key = search_key->second;
+      this->_state->cur_press_keys.erase(
+          std::remove(this->_state->cur_press_keys.begin(), this->_state->cur_press_keys.end(), key_code),
+          this->_state->cur_press_keys.end());
+
+      libevdev_uinput_write_event(keyboard, EV_MSC, MSC_SCAN, mapped_key.scan_code);
+      libevdev_uinput_write_event(keyboard, EV_KEY, mapped_key.linux_code, 0);
+      libevdev_uinput_write_event(keyboard, EV_SYN, SYN_REPORT, 0);
+    }
+  }
+}
+
+} // namespace inputtino