[Mammoth] Add a keyboard library that translates scancode to keycodes.

lib/mammoth/input/keyboard.cpp

@@ -0,0 +1,173 @@
+#include "input/keyboard.h"
+
+#include <voyageurs/voyageurs.yunq.client.h>
+#include <yellowstone/yellowstone.yunq.client.h>
+#include <zglobal.h>
+
+#include "util/debug.h"
+
+namespace mmth {
+namespace {
+
+void KeyboardListenerEntry(void* keyboard_base) {
+  reinterpret_cast<KeyboardListenerBase*>(keyboard_base)->ListenLoop();
+}
+
+}  // namespace
+
+KeyboardListenerBase::KeyboardListenerBase() {
+  auto server_or = PortServer::Create();
+  if (!server_or) {
+    crash("Failed to create server", server_or.error());
+  }
+  server_ = server_or.value();
+}
+
+void KeyboardListenerBase::Register() {
+  YellowstoneClient client(gInitEndpointCap);
+
+  GetEndpointRequest req;
+  req.set_endpoint_name("voyageurs");
+  Endpoint endpt;
+  check(client.GetEndpoint(req, endpt));
+
+  VoyageursClient vclient(endpt.endpoint());
+  KeyboardListener listn;
+
+  // TODO: Create a "ASSIGN_OR_CRASH" macro to simplify this.
+  auto client_or = server_.CreateClient();
+  if (!client_or.ok()) {
+    crash("Failed to create client", client_or.error());
+  }
+  listn.set_port_capability(client_or.value().cap());
+  None n;
+  check(vclient.RegisterKeyboardListener(listn, n));
+}
+
+Thread KeyboardListenerBase::Listen() {
+  return Thread(KeyboardListenerEntry, this);
+}
+
+void KeyboardListenerBase::ListenLoop() {
+  while (true) {
+    auto scancode_or = server_.RecvChar();
+    if (!scancode_or.ok()) {
+      check(scancode_or.error());
+    }
+    uint8_t scancode = scancode_or.value();
+    Keycode k = ScancodeToKeycode(scancode);
+    Action a = ScancodeToAction(scancode);
+    HandleKeycode(k, a);
+  }
+}
+
+void KeyboardListenerBase::HandleKeycode(Keycode code, Action action) {
+  char c = '\0';
+
+  if (action == kPressed) {
+    if (code >= kA && code <= kZ) {
+      const char* alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+      c = alpha[code - kA];
+    } else if (code >= k1 && code <= k0) {
+      const char* num = "1234567890";
+      c = num[code - k1];
+    } else if (code == kEnter) {
+      c = '\n';
+    } else if (code == kSpace) {
+      c = ' ';
+    }
+  }
+
+  if (c != '\0') {
+    HandleCharacter(c);
+  }
+}
+
+Keycode KeyboardListenerBase::ScancodeToKeycode(uint8_t scancode) {
+  // Cancel out the released bit.
+  scancode &= 0x7F;
+  switch (scancode) {
+    case 0x02:
+      return k1;
+    case 0x03:
+      return k2;
+    case 0x04:
+      return k3;
+    case 0x05:
+      return k4;
+    case 0x06:
+      return k5;
+    case 0x07:
+      return k6;
+    case 0x08:
+      return k7;
+    case 0x09:
+      return k8;
+    case 0x0A:
+      return k9;
+    case 0x0B:
+      return k0;
+    case 0x10:
+      return kQ;
+    case 0x11:
+      return kW;
+    case 0x12:
+      return kE;
+    case 0x13:
+      return kR;
+    case 0x14:
+      return kT;
+    case 0x15:
+      return kY;
+    case 0x16:
+      return kU;
+    case 0x17:
+      return kI;
+    case 0x18:
+      return kO;
+    case 0x19:
+      return kP;
+    case 0x1E:
+      return kA;
+    case 0x1F:
+      return kS;
+    case 0x20:
+      return kD;
+    case 0x21:
+      return kF;
+    case 0x22:
+      return kG;
+    case 0x23:
+      return kH;
+    case 0x24:
+      return kJ;
+    case 0x25:
+      return kK;
+    case 0x26:
+      return kL;
+    case 0x2C:
+      return kZ;
+    case 0x2D:
+      return kX;
+    case 0x2E:
+      return kC;
+    case 0x2F:
+      return kV;
+    case 0x30:
+      return kB;
+    case 0x31:
+      return kN;
+    case 0x32:
+      return kM;
+  }
+
+  dbgln("Unknown scancode {x}", scancode);
+
+  return kUnknownKeycode;
+}
+
+Action KeyboardListenerBase::ScancodeToAction(uint8_t scancode) {
+  return (scancode & 0x80) ? kReleased : kPressed;
+}
+
+}  // namespace mmth