apps/graphics: Refactor monkey using input generator library

Signed-off-by: liuchan3 <liuchan3@xiaomi.com>

Author: xiaoliud

graphics/input/CMakeLists.txt

@@ -41,6 +41,8 @@ if(CONFIG_GRAPHICS_INPUT_MONKEY)
     ${CONFIG_GRAPHICS_INPUT_MONKEY_STACKSIZE}
     MODULE
     ${CONFIG_GRAPHICS_INPUT_MONKEY}
+    DEPENDS
+    input_generator
     SRCS
     ${SRCS})
 endif()

graphics/input/Kconfig

@@ -4,7 +4,7 @@
 #
 
 config GRAPHICS_INPUT_GENERATOR
-	bool "Input generator library"
+	bool
 	default n
 	---help---
 		This is a simple input generator library that can be used to
@@ -14,6 +14,7 @@ menuconfig GRAPHICS_INPUT_MONKEY
 	tristate "Monkey test"
 	select UINPUT_TOUCH
 	select UINPUT_BUTTONS
+	select GRAPHICS_INPUT_GENERATOR
 	select LIBC_PRINT_EXTENSION
 	default n
 

graphics/input/monkey/monkey.c

@@ -25,6 +25,7 @@
  ****************************************************************************/
 
 #include <nuttx/config.h>
+#include <graphics/input_gen.h>
 #include <stdlib.h>
 #include <string.h>
 #include <inttypes.h>
@@ -41,8 +42,6 @@
 
 #define MONKEY_DEV_PATH_TOUCH "/dev/input0"
 #define MONKEY_DEV_PATH_BUTTON "/dev/buttons"
-#define MONKEY_DEV_PATH_UTOUCH "/dev/utouch"
-#define MONKEY_DEV_PATH_UBUTTON "/dev/ubutton"
 
 #define MONKEY_DEV_CREATE_MATCH(monkey, type_mask, type)                  \
 do {                                                                      \
@@ -60,6 +59,23 @@ do {                                                                      \
     }                                                                     \
 } while (0)
 
+#define MONKEY_DEV_CREATE_UINPUT(monkey, _type)                              \
+do {                                                                         \
+  if (input_gen_query_device(monkey->input_gen_ctx, INPUT_GEN_DEV_##_type))  \
+    {                                                                        \
+      FAR struct monkey_dev_s *dev = calloc(1, sizeof(struct monkey_dev_s)); \
+      if (!dev)                                                              \
+        {                                                                    \
+          MONKEY_LOG_ERROR("Failed to create virtual device");               \
+          goto failed;                                                       \
+        }                                                                    \
+      dev->type = MONKEY_DEV_TYPE_##_type;                                   \
+      dev->is_available = true;                                              \
+      (monkey)->devs[(monkey)->dev_num] = dev;                               \
+      (monkey)->dev_num++;                                                   \
+  }                                                                          \
+} while (0)
+
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -75,8 +91,15 @@ FAR struct monkey_s *monkey_create(int dev_type_mask)
 
   if (MONKEY_IS_UINPUT_TYPE(dev_type_mask))
     {
-      MONKEY_DEV_CREATE_MATCH(monkey, dev_type_mask, UTOUCH);
-      MONKEY_DEV_CREATE_MATCH(monkey, dev_type_mask, UBUTTON);
+      if (input_gen_create(&monkey->input_gen_ctx,
+                           MONKEY_GET_DEV_TYPE(dev_type_mask)) < 0)
+        {
+          MONKEY_LOG_ERROR("input generator create failed");
+          goto failed;
+        }
+
+      MONKEY_DEV_CREATE_UINPUT(monkey, UTOUCH);
+      MONKEY_DEV_CREATE_UINPUT(monkey, UBUTTON);
     }
   else
     {
@@ -110,6 +133,12 @@ void monkey_delete(FAR struct monkey_s *monkey)
   int i;
   MONKEY_ASSERT_NULL(monkey);
 
+  if (monkey->input_gen_ctx)
+    {
+      input_gen_reset_devices(monkey->input_gen_ctx, INPUT_GEN_DEV_ALL);
+      input_gen_destroy(monkey->input_gen_ctx);
+    }
+
   for (i = 0; i < monkey->dev_num; i++)
     {
       monkey_dev_delete(monkey->devs[i]);

graphics/input/monkey/monkey_dev.c

@@ -27,6 +27,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
+#include <graphics/input_gen.h>
 #include <nuttx/input/buttons.h>
 #include <nuttx/input/touchscreen.h>
 #include <poll.h>
@@ -48,41 +49,43 @@
  * Name: utouch_write
  ****************************************************************************/
 
-static void utouch_write(int fd, int x, int y, int touch_down)
+static void utouch_write(input_gen_ctx_t input_gen_ctx,
+                         FAR const struct monkey_dev_state_s *state)
 {
   struct touch_sample_s sample;
+  sample.npoints = 1;
+  input_gen_fill_point(sample.point, state->data.touch.x,
+                       state->data.touch.y,
+                       state->data.touch.is_pressed ? TOUCH_DOWN : TOUCH_UP);
 
-  if (touch_down)
+  if (input_gen_write_raw(input_gen_ctx, INPUT_GEN_DEV_UTOUCH, &sample,
+                          sizeof(struct touch_sample_s)) < 0)
     {
-      sample.point[0].x        = x;
-      sample.point[0].y        = y;
-      sample.point[0].pressure = 42;
-      sample.point[0].flags    = TOUCH_DOWN | TOUCH_ID_VALID |
-                                 TOUCH_POS_VALID | TOUCH_PRESSURE_VALID;
+      MONKEY_LOG_WARN("unsupported device type: %d", INPUT_GEN_DEV_UTOUCH);
+      return;
     }
-  else
-    {
-      sample.point[0].flags = TOUCH_UP | TOUCH_ID_VALID;
-    }
-
-  sample.npoints    = 1;
-  sample.point[0].h = 1;
-  sample.point[0].w = 1;
 
-  write(fd, &sample, sizeof(struct touch_sample_s));
   MONKEY_LOG_INFO("%s at x = %d, y = %d",
-                  touch_down ? "PRESS  " : "RELEASE", x, y);
+                  state->data.touch.is_pressed ? "PRESS" : "RELEASE",
+                  state->data.touch.x, state->data.touch.y);
 }
 
 /****************************************************************************
  * Name: ubutton_write
  ****************************************************************************/
 
-static void ubutton_write(int fd, uint32_t btn_bits)
+static void ubutton_write(input_gen_ctx_t input_gen_ctx,
+                          FAR const struct monkey_dev_state_s *state)
 {
-  btn_buttonset_t buttonset = btn_bits;
-  write(fd, &buttonset, sizeof(buttonset));
-  MONKEY_LOG_INFO("btn = 0x%08X", btn_bits);
+  btn_buttonset_t buttonset = state->data.button.value;
+  if (input_gen_write_raw(input_gen_ctx, INPUT_GEN_DEV_UBUTTON, &buttonset,
+                          sizeof(buttonset)) < 0)
+    {
+      MONKEY_LOG_WARN("unsupported device type: %d", INPUT_GEN_DEV_UBUTTON);
+      return;
+    }
+
+  MONKEY_LOG_INFO("btn = 0x%08X", state->data.button.value);
 }
 
 /****************************************************************************
@@ -152,18 +155,12 @@ FAR struct monkey_dev_s *monkey_dev_create(FAR const char *dev_path,
   int fd;
 
   MONKEY_ASSERT_NULL(dev_path);
+  MONKEY_ASSERT(!MONKEY_IS_UINPUT_TYPE(type));
 
   dev = calloc(1, sizeof(struct monkey_dev_s));
   MONKEY_ASSERT_NULL(dev);
 
-  if (MONKEY_IS_UINPUT_TYPE(type))
-    {
-      oflag = O_RDWR | O_NONBLOCK;
-    }
-  else
-    {
-      oflag = O_RDONLY | O_NONBLOCK;
-    }
+  oflag = O_RDONLY | O_NONBLOCK;
 
   fd = open(dev_path, oflag);
   if (fd < 0)
@@ -204,13 +201,6 @@ void monkey_dev_delete(FAR struct monkey_dev_s *dev)
 
   if (dev->fd > 0)
     {
-      /* Reset input state */
-
-      struct monkey_dev_state_s state;
-      memset(&state, 0, sizeof(state));
-      state.type = dev->type;
-      monkey_dev_set_state(dev, &state);
-
       MONKEY_LOG_NOTICE("close fd: %d", dev->fd);
       close(dev->fd);
     }
@@ -222,23 +212,24 @@ void monkey_dev_delete(FAR struct monkey_dev_s *dev)
  * Name: monkey_dev_set_state
  ****************************************************************************/
 
-void monkey_dev_set_state(FAR struct monkey_dev_s *dev,
+void monkey_dev_set_state(input_gen_ctx_t input_gen_ctx,
                           FAR const struct monkey_dev_state_s *state)
 {
-  MONKEY_ASSERT_NULL(dev);
+  MONKEY_ASSERT_NULL(input_gen_ctx);
 
-  switch (MONKEY_GET_DEV_TYPE(dev->type))
+  switch (MONKEY_GET_DEV_TYPE(state->type))
     {
       case MONKEY_DEV_TYPE_TOUCH:
-        utouch_write(dev->fd,
-                    state->data.touch.x,
-                    state->data.touch.y,
-                    state->data.touch.is_pressed);
-        break;
+        {
+          utouch_write(input_gen_ctx, state);
+          break;
+        }
 
       case MONKEY_DEV_TYPE_BUTTON:
-        ubutton_write(dev->fd, state->data.button.value);
-        break;
+        {
+          ubutton_write(input_gen_ctx, state);
+          break;
+        }
 
       default:
         break;
@@ -280,7 +271,7 @@ bool monkey_dev_get_state(FAR struct monkey_dev_s *dev,
 }
 
 /****************************************************************************
- * Name: monkey_dev_get_state
+ * Name: monkey_dev_get_type
  ****************************************************************************/
 
 enum monkey_dev_type_e monkey_dev_get_type(

graphics/input/monkey/monkey_dev.h

@@ -69,7 +69,7 @@ void monkey_dev_delete(FAR struct monkey_dev_s *dev);
  * Name: monkey_dev_set_state
  ****************************************************************************/
 
-void monkey_dev_set_state(FAR struct monkey_dev_s *dev,
+void monkey_dev_set_state(input_gen_ctx_t input_gen_ctx,
                           FAR const struct monkey_dev_state_s *state);
 
 /****************************************************************************

graphics/input/monkey/monkey_event.c

@@ -26,47 +26,12 @@
 
 #include <string.h>
 #include <unistd.h>
+#include <graphics/input_gen.h>
 #include "monkey_dev.h"
 #include "monkey_event.h"
 #include "monkey_log.h"
 #include "monkey_utils.h"
 
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: monkey_exec_darg
- ****************************************************************************/
-
-static bool monkey_exec_darg(FAR struct monkey_dev_s *dev,
-                             FAR struct monkey_dev_state_s *state,
-                             FAR const struct monkey_event_param_s *param)
-{
-  int t = 0;
-  uint32_t start;
-  state->data.touch.is_pressed = true;
-
-  start = monkey_tick_get();
-
-  while (t < param->duration)
-    {
-      t = monkey_tick_elaps(monkey_tick_get(), start);
-      state->data.touch.x = monkey_map(t, 0, param->duration,
-                                       param->x1, param->x2);
-      state->data.touch.y = monkey_map(t, 0, param->duration,
-                                       param->y1, param->y2);
-      monkey_dev_set_state(dev, state);
-
-      if (usleep(1000) < 0)
-        {
-          return false;
-        }
-    }
-
-  return true;
-}
-
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -143,60 +108,46 @@ bool monkey_event_exec(FAR struct monkey_s *monkey,
                        FAR const struct monkey_event_param_s *param)
 {
   bool retval = false;
-  struct monkey_dev_state_s state;
-  memset(&state, 0, sizeof(struct monkey_dev_state_s));
-  state.type = monkey_dev_get_type(dev);
-
+  enum monkey_dev_type_e dev_type = monkey_dev_get_type(dev);
   MONKEY_LOG_INFO("dev=0x%x event=%d(%s) duration=%d"
                   " x1=%d y1=%d x2=%d y2=%d",
-                  state.type,
+                  dev_type,
                   param->event,
                   monkey_event_type2name(param->event),
                   param->duration,
                   param->x1, param->y1,
                   param->x2, param->y2);
 
-  if (state.type & MONKEY_DEV_TYPE_TOUCH)
+  if (dev_type & MONKEY_DEV_TYPE_TOUCH)
     {
-      state.data.touch.x = param->x1;
-      state.data.touch.y = param->y1;
-      state.data.touch.is_pressed = true;
-      monkey_dev_set_state(dev, &state);
-
       if (param->event == MONKEY_EVENT_DRAG)
         {
-          retval = monkey_exec_darg(dev, &state, param);
+          retval = !input_gen_drag(monkey->input_gen_ctx,
+                                   param->x1, param->y1,
+                                   param->x2, param->y2,
+                                   param->duration);
         }
       else
         {
-          retval = usleep(param->duration * 1000) == 0;
+          /* Use swipe with same start and end point to simulate click or
+           * longpress.
+           */
+
+          retval = !input_gen_swipe(monkey->input_gen_ctx,
+                                    param->x1, param->y1,
+                                    param->x1, param->y1,
+                                    param->duration);
         }
-
-      if (!retval)
-        {
-          MONKEY_LOG_NOTICE("detect monkey killed");
-        }
-
-      state.data.touch.is_pressed = false;
-      monkey_dev_set_state(dev, &state);
     }
-  else if (state.type & MONKEY_DEV_TYPE_BUTTON)
+  else if (dev_type & MONKEY_DEV_TYPE_BUTTON)
     {
-      /* press button */
-
-      state.data.button.value = 1 << monkey->config.btn_bit;
-      monkey_dev_set_state(dev, &state);
-
-      retval = usleep(param->duration * 1000) == 0;
-
-      /* release button */
-
-      state.data.button.value = 0;
-      monkey_dev_set_state(dev, &state);
+      retval = !input_gen_button_longpress(monkey->input_gen_ctx,
+                                           1 << monkey->config.btn_bit,
+                                           param->duration);
     }
   else
     {
-      MONKEY_LOG_WARN("unsupport device type: %d", state.type);
+      MONKEY_LOG_WARN("unsupported device type: %d", dev_type);
     }
 
   return retval;

graphics/input/monkey/monkey_main.c

@@ -532,7 +532,7 @@ static enum monkey_wait_res_e monkey_wait(uint32_t ms)
         }
       else
         {
-          MONKEY_LOG_ERROR("Unknow error: %d", errcode);
+          MONKEY_LOG_ERROR("Unknown error: %d", errcode);
         }
     }
   else if (ret == SIGTSTP)