Add keyboard device

Change-Id: I788ce93d738d6e1e284b1f12de0ddb94592339e2

diff --git a/src/Makefile.am b/src/Makefile.am
index 7aec759..13fb3ed 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -10,4 +10,5 @@ headless_server_SOURCES = headless_server.c \
                          output/HL_UI_LED_APA102.c \
                          output/boot_anim.c \
                          shell/shell.c \
-                         debug/debug.c
+                         debug/debug.c \
+                         input/input.c

diff --git a/src/headless_server.c b/src/headless_server.c
index cb1487d..ef8a773 100644 (file)
--- a/src/headless_server.c
+++ b/src/headless_server.c
@@ -129,11 +129,9 @@ int main(int argc, char *argv[])
        server.debug = headless_debug_create(&server);
        HEADLESS_CHECK(server.debug, goto end, "headless_debug_create() failed\n");
 
-#ifndef DISABLE_INPUT
        /* Init input for headless */
-       ret = headless_input_init(compositor);
-       HEADLESS_CHECK(ret, goto end, "headless_input_init() failed\n");
-#endif
+       server.input = headless_input_create(server.display);
+       HEADLESS_CHECK(server.input, goto end, "headless_input_create() failed\n");
 
        /* Init Output */
        if(use_output)
@@ -187,9 +185,8 @@ end:
        if (server.debug)
                headless_debug_destroy(server.debug);
 
-#ifndef DISABLE_INPUT
-       headless_input_deinit(compositor);
-#endif
+       if (server.input)
+               headless_input_destroy(server.input);
 
        wl_display_destroy_clients(server.display);
        wl_display_destroy(server.display);

diff --git a/src/headless_server.h b/src/headless_server.h
index 91dc7e3..22205fa 100644 (file)
--- a/src/headless_server.h
+++ b/src/headless_server.h
@@ -28,8 +28,6 @@
 extern "C" {
 #endif
 
-#define DISABLE_INPUT
-
 #include <stdbool.h>
 
 #include <wayland-server.h>
@@ -71,6 +69,8 @@ typedef struct HEADLESS_SHELL_SURFACE headless_shell_surface_t;
 
 typedef struct headless_debug headless_debug_t;
 
+typedef struct headless_input headless_input_t;
+
 struct headless_server
 {
        struct wl_display *display;
@@ -78,6 +78,7 @@ struct headless_server
        struct ds_tbm_server *tbm_server;
 
        led_output_t *output;
+    headless_input_t *input;
        headless_shell_t *shell;
        headless_debug_t *debug;
 
@@ -155,15 +156,9 @@ headless_shell_surface_get_resource(headless_shell_surface_t *hs_surface);
 headless_debug_t *headless_debug_create(headless_server_t *server);
 void headless_debug_destroy(headless_debug_t *hdebug);;
 
-#ifndef DISABLE_INPUT
 /* APIs for headless_input */
-pepper_bool_t headless_input_init(pepper_compositor_t *compositor);
-void headless_input_deinit(pepper_compositor_t *compositor);
-void headless_input_set_focus_view(pepper_compositor_t *compositor, pepper_view_t *view);
-void headless_input_set_top_view(pepper_compositor_t *compositor, pepper_view_t *view);
-void *headless_input_get_keyrouter(pepper_compositor_t *compositor);
-void *headless_input_get_xkb(pepper_compositor_t *compositor);
-#endif
+headless_input_t *headless_input_create(struct wl_display *display);
+void headless_input_destroy(headless_input_t *input);
 
 #ifdef __cplusplus
 }

diff --git a/src/input/input.c b/src/input/input.c
index ac70aa3..c4f97af 100644 (file)
--- a/src/input/input.c
+++ b/src/input/input.c
@@ -21,6 +21,178 @@
 * DEALINGS IN THE SOFTWARE.
 */
 
+#define USE_LIBDS
+
+#ifdef USE_LIBDS
+#include <stdlib.h>
+
+#include <wayland-server.h>
+#include <libds/log.h>
+#include <libds/backend/libinput.h>
+#include <libds/input_device.h>
+#include <libds/keyboard.h>
+
+typedef struct headless_input headless_input_t;
+typedef struct headless_keyboard headless_keyboard_t;
+
+struct headless_input
+{
+       headless_keyboard_t *keyboard;
+
+       struct wl_display *display;
+       struct ds_backend *backend;
+
+       struct wl_listener new_input;
+};
+
+struct headless_keyboard
+{
+       headless_input_t *input;
+
+       struct ds_input_device *dev;
+
+       struct wl_listener device_destroy;
+       struct wl_listener key;
+};
+
+static void handle_new_input(struct wl_listener *listener, void *data);
+static void add_keyboard(headless_input_t *input, struct ds_input_device *dev);
+static void keyboard_destroy(headless_keyboard_t *keyboard);
+static void keyboard_handle_destroy(struct wl_listener *listener, void *data);
+static void keyboard_handle_key(struct wl_listener *listener, void *data);
+
+headless_input_t *
+headless_input_create(struct wl_display *display)
+{
+       headless_input_t *input;
+
+       input = calloc(1, sizeof *input);
+       if (!input)
+               return NULL;
+
+       input->display = display;
+
+       input->backend = ds_libinput_backend_create(display);
+       if (!input->backend) {
+               ds_err("Could not create libinput backend");
+               free(input);
+               return NULL;
+       }
+
+       input->new_input.notify = handle_new_input;
+       ds_backend_add_new_input_listener(input->backend, &input->new_input);
+
+       ds_backend_start(input->backend);
+
+       ds_inf("Created Headless input(%p)", input);
+
+       return input;
+}
+
+void
+headless_input_destroy(headless_input_t *input)
+{
+       if (input->keyboard)
+               keyboard_destroy(input->keyboard);
+
+       wl_list_remove(&input->new_input.link);
+       ds_backend_destroy(input->backend);
+       free(input);
+}
+
+
+static void
+handle_new_input(struct wl_listener *listener, void *data)
+{
+       headless_input_t *input;
+       struct ds_input_device *dev = data;
+       enum ds_input_device_type dev_type;
+
+       input = wl_container_of(listener, input, new_input);
+
+       dev_type = ds_input_device_get_type(dev);
+
+       ds_inf("Input(%p): New input device(%p) type(%d)",
+                       input, dev, ds_input_device_get_type(dev));
+
+       switch (dev_type) {
+               case DS_INPUT_DEVICE_KEYBOARD:
+                       add_keyboard(input, dev);
+                       break;
+               default:
+                       ds_inf("Not supported device, type(%d)", dev_type);
+                       break;
+       }
+}
+
+static void
+add_keyboard(headless_input_t *input, struct ds_input_device *dev)
+{
+       headless_keyboard_t *keyboard;
+       struct ds_keyboard *ds_keyboard;
+
+       if (input->keyboard) {
+               ds_inf("Already created keyboard device(%p)", input->keyboard);
+               return;
+       }
+
+       keyboard = calloc(1, sizeof *keyboard);
+       if (!keyboard) {
+               ds_err("Could not allocate memory");
+               return;
+       }
+
+       keyboard->input = input;
+       keyboard->dev = dev;
+
+       keyboard->device_destroy.notify = keyboard_handle_destroy;
+       ds_input_device_add_destroy_listener(dev, &keyboard->device_destroy);
+
+       ds_keyboard = ds_input_device_get_keyboard(dev);
+
+       keyboard->key.notify = keyboard_handle_key;
+       ds_keyboard_add_key_listener(ds_keyboard, &keyboard->key);
+
+       input->keyboard = keyboard;
+
+       ds_inf("Input(%p): New keyboard(%p)", input, keyboard);
+}
+
+static void
+keyboard_destroy(headless_keyboard_t *keyboard)
+{
+       ds_inf("Keyboard(%p) destroyed", keyboard);
+
+       wl_list_remove(&keyboard->key.link);
+       wl_list_remove(&keyboard->device_destroy.link);
+       free(keyboard);
+}
+
+static void
+keyboard_handle_destroy(struct wl_listener *listener, void *data)
+{
+       headless_keyboard_t *keyboard;
+
+       keyboard = wl_container_of(listener, keyboard, device_destroy);
+
+       keyboard->input->keyboard = NULL;
+
+       keyboard_destroy(keyboard);
+}
+
+static void
+keyboard_handle_key(struct wl_listener *listener, void *data)
+{
+       headless_keyboard_t *keyboard;
+       struct ds_event_keyboard_key *event = data;
+
+       keyboard = wl_container_of(listener, keyboard, key);
+
+       ds_inf("Keyboard(%p) key: keycode(%d), state(%d), time_msec(%d), "
+                       "update_state(%d)", keyboard, event->keycode, event->state,
+                       event->time_msec, event->update_state);
+}
+#else
 #include <pepper-evdev.h>
 #include <pepper-input-backend.h>
 #include <pepper-keyrouter.h>
@@ -595,3 +767,4 @@ error:
 
        return PEPPER_FALSE;
 }
+#endif