feat(uinput): add repeat rate support

Author: haithium

src/evdev/uinput.c

@@ -284,6 +284,16 @@ int evdev_create_uinput(lua_State *L) {
   uinput->created = 1;
   uinput->path = NULL;
   luaL_setmetatable(L, EVDEV_UINPUT_MT);
+
+  result = evdev_cache_uinput_path(L, uinput);
+  if (result != 0) {
+    (void)ioctl(fd, UI_DEV_DESTROY);
+    evdev_close_fd(&fd);
+    uinput->fd = -1;
+    uinput->created = 0;
+    return result;
+  }
+
   return 1;
 }
 
@@ -336,6 +346,104 @@ static int evdev_uinput_sync(lua_State *L) {
   return evdev_emit_raw(L, uinput->fd, EV_SYN, SYN_REPORT, 0);
 }
 
+static int evdev_push_repeat_unsupported(lua_State *L, const char *action,
+                                         const char *path) {
+  lua_pushnil(L);
+  lua_pushfstring(L, "%s %s: device does not support repeat settings", action,
+                  path != NULL ? path : "<unknown>");
+  return 2;
+}
+
+static int evdev_uinput_open_event_node(lua_State *L, evdev_uinput_t *uinput,
+                                        int flags) {
+  int err_result;
+  int fd;
+
+  err_result = evdev_cache_uinput_path(L, uinput);
+  if (err_result != 0) {
+    return -1;
+  }
+
+  fd = evdev_open_cloexec(uinput->path, flags | O_NONBLOCK);
+  if (fd < 0) {
+    (void)evdev_push_errno(L, "open", uinput->path);
+    return -1;
+  }
+
+  return fd;
+}
+
+static int evdev_uinput_set_repeat(lua_State *L) {
+  evdev_uinput_t *uinput = evdev_check_uinput(L, 1);
+  unsigned int repeat[2];
+  lua_Integer delay = luaL_checkinteger(L, 2);
+  lua_Integer period = luaL_checkinteger(L, 3);
+  int err_result;
+  int fd;
+
+  luaL_argcheck(L, delay >= 0, 2, "delay must be non-negative");
+  luaL_argcheck(L, period >= 0, 3, "period must be non-negative");
+
+  err_result = evdev_check_open_uinput(L, uinput);
+  if (err_result != 0) {
+    return err_result;
+  }
+
+  fd = evdev_uinput_open_event_node(L, uinput, O_RDWR);
+  if (fd < 0) {
+    return 2;
+  }
+
+  repeat[0] = (unsigned int)delay;
+  repeat[1] = (unsigned int)period;
+
+  if (ioctl(fd, EVIOCSREP, repeat) < 0) {
+    int saved_errno = errno;
+    evdev_close_fd(&fd);
+    errno = saved_errno;
+    if (errno == ENOSYS || errno == ENOTTY || errno == EINVAL) {
+      return evdev_push_repeat_unsupported(L, "set repeat", uinput->path);
+    }
+    return evdev_push_errno(L, "set repeat", uinput->path);
+  }
+
+  evdev_close_fd(&fd);
+  lua_pushboolean(L, 1);
+  return 1;
+}
+
+static int evdev_uinput_get_repeat(lua_State *L) {
+  evdev_uinput_t *uinput = evdev_check_uinput(L, 1);
+  unsigned int repeat[2] = {0, 0};
+  int err_result;
+  int fd;
+
+  err_result = evdev_check_open_uinput(L, uinput);
+  if (err_result != 0) {
+    return err_result;
+  }
+
+  fd = evdev_uinput_open_event_node(L, uinput, O_RDONLY);
+  if (fd < 0) {
+    return 2;
+  }
+
+  if (ioctl(fd, EVIOCGREP, repeat) < 0) {
+    int saved_errno = errno;
+    evdev_close_fd(&fd);
+    errno = saved_errno;
+    if (errno == ENOSYS || errno == ENOTTY || errno == EINVAL) {
+      return evdev_push_repeat_unsupported(L, "get repeat", uinput->path);
+    }
+    return evdev_push_errno(L, "get repeat", uinput->path);
+  }
+
+  evdev_close_fd(&fd);
+  lua_pushinteger(L, repeat[0]);
+  lua_pushinteger(L, repeat[1]);
+  return 2;
+}
+
 static int evdev_uinput_close(lua_State *L) {
   evdev_uinput_t *uinput = evdev_check_uinput(L, 1);
   int destroy_errno = 0;
@@ -451,10 +559,16 @@ static int evdev_uinput_tostring(lua_State *L) {
 }
 
 const luaL_Reg evdev_uinput_methods[] = {
-    {"emit", evdev_uinput_emit},     {"sync", evdev_uinput_sync},
-    {"close", evdev_uinput_close},   {"is_open", evdev_uinput_is_open},
-    {"path", evdev_uinput_get_path}, {"info", evdev_uinput_info},
-    {"fd", evdev_uinput_fd},         {NULL, NULL},
+    {"emit", evdev_uinput_emit},
+    {"sync", evdev_uinput_sync},
+    {"set_repeat", evdev_uinput_set_repeat},
+    {"get_repeat", evdev_uinput_get_repeat},
+    {"close", evdev_uinput_close},
+    {"is_open", evdev_uinput_is_open},
+    {"path", evdev_uinput_get_path},
+    {"info", evdev_uinput_info},
+    {"fd", evdev_uinput_fd},
+    {NULL, NULL},
 };
 
 const luaL_Reg evdev_uinput_meta[] = {

src/evdev/uinput.lua

@@ -176,6 +176,20 @@ function UInput:emit(type, code, value)
   return call_uinput(self, "emit", type, code, value)
 end
 
+function UInput:set_repeat(delay, period)
+  validate("delay", delay, "number")
+  validate("period", period, "number")
+  return call_uinput(self, "set_repeat", delay, period)
+end
+
+function UInput:get_repeat()
+  local delay, period = call_uinput(self, "get_repeat")
+  if not delay then
+    return nil, nil, period
+  end
+  return delay, period
+end
+
 function UInput:is_open()
   local core = rawget(self, "_core")
   return core ~= nil and core:is_open()

tests/uinput.test.lua

@@ -7,6 +7,7 @@ local UInput = evdev.uinput.create
 local normalize = evdev.uinput._normalize ---@diagnostic disable-line: undefined-field
 local ecodes = evdev.ecodes
 local sleep = system.sleep
+local fmt = string.format
 
 describe("evdev.uinput()", function()
   describe("validations", function()
@@ -182,24 +183,31 @@ describe("evdev.uinput()", function()
   end)
 
   describe("UInput object", function()
+    local ui
+
+    before_each(function()
+      if not (ui and ui:is_open()) then
+        ui = assert(UInput({ name = "Lua Virtual Device" }))
+        sleep(0.1)
+      end
+    end)
+
+    teardown(function()
+      ui:close()
+    end)
+
     it("loads metadata fields", function()
-      local ui = assert(UInput({ name = "cached mock device" }))
-      sleep(0.1)
       assert.Match("^/dev/input/event%d+$", ui.path)
-      assert.Equal("cached mock device", ui.name)
-      assert.True(ui:close())
+      assert.Equal("Lua Virtual Device", ui.name)
     end)
 
     it("reports open state and closes cleanly", function()
-      local ui = assert(UInput({ name = "mock open state" }))
       assert.True(ui:is_open())
       assert.True(ui:close())
       assert.False(ui:is_open())
-      assert.True(ui:close())
     end)
 
     it("returns a closed-device error for emit after close", function()
-      local ui = assert(UInput({ name = "closed emit test" }))
       assert.True(ui:close())
 
       local ok, err = ui:emit(ecodes.EV_KEY, ecodes.KEY_A, 1)
@@ -208,14 +216,76 @@ describe("evdev.uinput()", function()
     end)
 
     it("returns a closed-device error for sync after close", function()
-      local ui = assert(UInput({ name = "closed sync test" }))
       assert.True(ui:close())
 
       local ok, err = ui:sync()
       assert.Nil(ok)
       assert.Equal("uinput device is closed", err)
     end)
 
+    it("returns repeat settings for repeat-capable devices", function()
+      local delay, period, err = ui:get_repeat()
+      assert.Number(delay)
+      assert.Number(period)
+      assert.Nil(err)
+    end)
+
+    it("updates repeat settings for repeat-capable devices", function()
+      local delay, period, err = ui:get_repeat()
+      assert.Number(delay)
+      assert.Number(period)
+      assert.Nil(err)
+      assert.True(ui:set_repeat(delay, period))
+    end)
+
+    it("returns an unsupported get_repeat error for non-repeat devices", function()
+      local ui = assert(UInput({
+        name = "uinput unsupported get repeat test",
+        keys = { ecodes.BTN_LEFT },
+        rels = { ecodes.REL_X },
+      }))
+
+      sleep(0.1)
+
+      local delay, period, err = ui:get_repeat()
+      assert.Nil(delay)
+      assert.Nil(period)
+      assert.Equal(fmt("get repeat %s: device does not support repeat settings", ui.path), err)
+      assert.True(ui:close())
+    end)
+
+    it("returns an unsupported set_repeat error for non-repeat devices", function()
+      local ui = assert(UInput({
+        name = "uinput unsupported set repeat test",
+        keys = { ecodes.BTN_RIGHT },
+        rels = { ecodes.REL_Y },
+      }))
+      sleep(0.1)
+      local ok, err = ui:set_repeat(300, 40)
+      assert.Nil(ok)
+      assert.Equal(fmt("set repeat %s: device does not support repeat settings", ui.path), err)
+      assert.True(ui:close())
+    end)
+
+    it("returns a closed-device error for get_repeat after close", function()
+      local ui = assert(UInput({ name = "closed get repeat test" }))
+      assert.True(ui:close())
+
+      local delay, period, err = ui:get_repeat()
+      assert.Nil(delay)
+      assert.Nil(period)
+      assert.Equal("uinput device is closed", err)
+    end)
+
+    it("returns a closed-device error for set_repeat after close", function()
+      local ui = assert(UInput({ name = "closed set repeat test" }))
+      assert.True(ui:close())
+
+      local ok, err = ui:set_repeat(300, 40)
+      assert.Nil(ok)
+      assert.Equal("uinput device is closed", err)
+    end)
+
     it("validates emit argument types before using the handle", function()
       local ui = assert(UInput({ name = "emit validation test" }))
 
@@ -233,5 +303,19 @@ describe("evdev.uinput()", function()
 
       ui:close()
     end)
+
+    it("validates set_repeat argument types before using the handle", function()
+      local ui = assert(UInput({ name = "set repeat validation test" }))
+
+      assert.Error(function()
+        ui:set_repeat("fast", 40)
+      end, "delay: (number expected, got string)")
+
+      assert.Error(function()
+        ui:set_repeat(300, "slow")
+      end, "period: (number expected, got string)")
+
+      ui:close()
+    end)
   end)
 end)

types/uinput.d.lua

@@ -50,6 +50,8 @@ function M.create(spec) end
 ---@field info fun(self: evdev.coreUInput): (info:evdev.deviceInfo?, err:string?)
 ---@field is_open fun(self: evdev.coreUInput): boolean
 ---@field sync fun(self: evdev.coreUInput): (ok:true?, err:string?)
+---@field set_repeat fun(self: evdev.coreUInput, delay:integer, period:integer): (ok:true?, err:string?)
+---@field get_repeat fun(self: evdev.coreUInput): (delay:integer?, period_or_err:(integer|string)?)
 
 ---
 ---Open virtual input device handle.
@@ -135,4 +137,40 @@ function UInput:emit(type, code, value) end
 ---@return string? err Error message on failure.
 function UInput:sync() end
 
+---
+---Set the keyboard repeat rate on the virtual device.
+---
+---```lua
+---local UInput = evdev.uinput.create
+---local ui = assert(UInput())
+---os.execute("sleep 0.5")
+---
+----- Set repeat delay to 500ms, repeat period to 50ms
+---ui:set_repeat(500, 50)
+---```
+---
+---@param delay integer Delay in milliseconds before key repeat starts.
+---@param period integer Period in milliseconds between repeated key events.
+---@return true? ok `true` when the repeat rate is set successfully.
+---@return string? err Error message on failure.
+function UInput:set_repeat(delay, period) end
+
+---
+---Get the current keyboard repeat rate from the virtual device.
+---
+---```lua
+---local UInput = evdev.uinput.create
+---local ui = assert(UInput())
+---os.execute("sleep 0.5")
+---
+---local delay, period, err = ui:get_repeat()
+---assert(delay, err)
+---print(delay, period)
+---```
+---
+---@return integer? delay Repeat delay in milliseconds.
+---@return integer? period Repeat period in milliseconds.
+---@return string? err Error message on failure.
+function UInput:get_repeat() end
+
 return M