# headless server
HEADLESS_SERVER_REQUIRES="wayland-server capi-system-peripheral-io xdg-shell-unstable-v6-server tizen-extension-server"
PKG_CHECK_MODULES(HEADLESS_SERVER, $[HEADLESS_SERVER_REQUIRES])
-HEADLESS_SERVER_CFLAGS="$PEPPER_DIR $PEPPER_KEYROUTER_DIR $PEPPER_EVDEV_DIR $HEADLESS_SERVER_CFLAGS $TBM_CFLAGS"
+HEADLESS_SERVER_CFLAGS="$PEPPER_DIR $PEPPER_KEYROUTER_DIR $PEPPER_DEVICEMGR_DIR $PEPPER_EVDEV_DIR $HEADLESS_SERVER_CFLAGS $TBM_CFLAGS"
HEADLESS_SERVER_CFLAGS="$PEPPER_XKB_DIR $HEADLESS_SERVER_CFLAGS"
HEADLESS_SERVER_LIBS="$PEPPER_LIB $PEPPER_LIBS $PEPPER_EVDEV_LIB $PEPPER_EVDEV_LIBS $HEADLESS_SERVER_LIBS $TBM_LIBS"
HEADLESS_SERVER_LIBS="$PEPPER_KEYROUTER_LIB $PEPPER_KEYROUTER_LIBS $HEADLESS_SERVER_LIBS"
+HEADLESS_SERVER_LIBS="$PEPPER_DEVICEMGR_LIB $PEPPER_DEVICEMGR_LIBS $HEADLESS_SERVER_LIBS"
HEADLESS_SERVER_LIBS="$PEPPER_XKB_LIB $PEPPER_XKB_LIBS $HEADLESS_SERVER_LIBS"
AC_SUBST(HEADLESS_SERVER_CFLAGS)
# doctor (headless server) and headless client samples
DOCTOR_SERVER_REQUIRES="wayland-server libtbm"
PKG_CHECK_MODULES(DOCTOR_SERVER, $[DOCTOR_SERVER_REQUIRES])
-DOCTOR_SERVER_CFLAGS="$PEPPER_DIR $PEPPER_EVDEV_DIR $PEPPER_KEYROUTER_DIR $PEPPER_DEVICEMGR_DIR $DOCTOR_SERVER_CFLAGS"
+DOCTOR_SERVER_CFLAGS="$PEPPER_DIR $PEPPER_EVDEV_DIR $PEPPER_XKB_DIR $PEPPER_KEYROUTER_DIR $PEPPER_DEVICEMGR_DIR $DOCTOR_SERVER_CFLAGS"
DOCTOR_SERVER_LIBS="$PEPPER_LIB $PEPPER_LIBS $DOCTOR_SERVER_LIBS"
DOCTOR_SERVER_LIBS="$PEPPER_EVDEV_LIB $PEPPER_EVDEV_LIBS $DOCTOR_SERVER_LIBS"
+DOCTOR_SERVER_LIBS="$PEPPER_XKB_LIB $PEPPER_XKB_LIBS $DOCTOR_SERVER_LIBS"
DOCTOR_SERVER_LIBS="$PEPPER_KEYROUTER_LIB $PEPPER_KEYROUTER_LIBS $PEPPER_DEVICEMGR_LIB $PEPPER_DEVICEMGR_LIBS $DOCTOR_SERVER_LIBS"
AC_SUBST(DOCTOR_SERVER_CFLAGS)
#include <pepper-evdev.h>
#include <pepper-input-backend.h>
#include <pepper-keyrouter.h>
+#include <pepper-devicemgr.h>
#include <pepper-xkb.h>
typedef struct
pepper_view_t *top_view;
pepper_keyrouter_t *keyrouter;
+ pepper_devicemgr_t *devicemgr;
pepper_xkb_t *xkb;
pepper_event_listener_t *listener_seat_keyboard_key;
{
uint32_t caps = 0;
uint32_t probed = 0;
-
- const char *seat_name = NULL;
pepper_evdev_t *evdev = NULL;
- pepper_seat_t *seat = NULL;
-
- seat_name = getenv("XDG_SEAT");
-
- if (!seat_name)
- seat_name = "seat0";
-
- /* create a default seat (seat0) */
- seat = pepper_compositor_add_seat(hi->compositor, seat_name);
- PEPPER_CHECK(seat, goto end, "Failed to add seat (%s)!\n", seat_name);
-
- hi->seat = seat;
/* create pepper evdev */
evdev = pepper_evdev_create(hi->compositor);
return PEPPER_TRUE;
end:
- if (seat)
- pepper_seat_destroy(seat);
pepper_evdev_destroy(evdev);
return PEPPER_FALSE;
static void
headless_input_init_modules(headless_input_t *hi)
{
+ const char *seat_name = NULL;
+ pepper_seat_t *seat = NULL;
+
pepper_keyrouter_t *keyrouter = NULL;
+ pepper_devicemgr_t *devicemgr = NULL;
pepper_xkb_t *xkb = NULL;
PEPPER_TRACE("[%s] ... begin\n", __FUNCTION__);
+ seat_name = getenv("XDG_SEAT");
+
+ if (!seat_name)
+ seat_name = "seat0";
+
+ /* create a default seat (seat0) */
+ seat = pepper_compositor_add_seat(hi->compositor, seat_name);
+ PEPPER_CHECK(seat, goto end, "Failed to add seat (%s)!\n", seat_name);
+
+ hi->seat = seat;
+
/* create pepper xkb */
xkb = pepper_xkb_create();
PEPPER_CHECK(xkb, goto end, "Failed to create pepper_xkb !\n");
hi->keyrouter = keyrouter;
+ /* create pepper devicemgr */
+ devicemgr = pepper_devicemgr_create(hi->compositor, hi->seat);
+ PEPPER_CHECK(devicemgr, goto end, "Failed to create devicemgr !\n");
+ pepper_devicemgr_xkb_enable(devicemgr);
+
+ hi->devicemgr = devicemgr;
+
PEPPER_TRACE("[%s] ... done\n", __FUNCTION__);
return;
pepper_xkb_destroy(hi->xkb);
if (hi->keyrouter)
pepper_keyrouter_destroy(hi->keyrouter);
+ if (hi->devicemgr)
+ pepper_devicemgr_destroy(hi->devicemgr);
+ if (hi->seat)
+ pepper_seat_destroy(hi->seat);
hi->xkb = NULL;
hi->keyrouter = NULL;
+ hi->devicemgr = NULL;
+ hi->seat = NULL;
}
static void
pepper_xkb_destroy(hi->xkb);
if (hi->keyrouter)
pepper_keyrouter_destroy(hi->keyrouter);
+ if (hi->devicemgr)
+ pepper_devicemgr_destroy(hi->devicemgr);
hi->xkb = NULL;
hi->keyrouter = NULL;
+ hi->devicemgr = NULL;
}
PEPPER_API void
#include "pepper-devicemgr.h"
#include "pepper-internal.h"
#include <tizen-extension-server-protocol.h>
-#ifdef _F_DEVICEMGR_XKB
#include <pepper-xkb.h>
-#endif
#define MIN(a,b) ((a)<(b)?(a):(b))
struct wl_display *display;
pepper_compositor_t *compositor;
pepper_seat_t *seat;
-#ifdef _F_DEVICEMGR_XKB
+ pepper_bool_t xkb_enabled;
pepper_xkb_info_t *xkb_info;
-#else
pepper_list_t *keymap_list;
-#endif
pepper_event_listener_t *listener_input_device_add;
-#ifdef _F_DEVICEMGR_XKB
pepper_event_listener_t *listener_seat_keyboard_add;
pepper_event_listener_t *listener_keyboard_keymap_update;
-#endif
pepper_list_t resources;
pepper_list_t link;
};
-#ifdef _F_DEVICEMGR_XKB
static void
_pepper_devicemgr_handle_keyboard_keymap_update(pepper_event_listener_t *listener, pepper_object_t *object, uint32_t id, void *info, void *data)
{
PEPPER_EVENT_KEYBOARD_KEYMAP_UPDATE, 0,
_pepper_devicemgr_handle_keyboard_keymap_update, pepper_devicemgr);
}
-#endif
static void
_pepper_devicemgr_handle_input_device_add(pepper_event_listener_t *listener, pepper_object_t *object, uint32_t id, void *info, void *data)
if (!strncmp(name, "Keycode-", sizeof("Keycode-")-1)) {
return atoi(name + 8);
}
- else if (!pepper_list_empty(list)) {
+ else if (list && !pepper_list_empty(list)) {
pepper_list_for_each(data, list, link) {
if (data) {
if (!strncmp(data->name, name, UINPUT_MAX_NAME_SIZE)) {
PEPPER_CHECK(pepper_devicemgr, goto failed, "pepper_devicemgr is not set\n");
PEPPER_CHECK(pepper_devicemgr->devicemgr, goto failed, "devicemgr is not created\n");
-#ifdef _F_DEVICEMGR_XKB
if (pepper_devicemgr->xkb_info) {
keycode = pepper_xkb_info_keyname_to_keycode(pepper_devicemgr->xkb_info, keyname);
- } else
-#else
- keycode = _pepper_devicemgr_keyname_to_keycode(pepper_devicemgr->keymap_list, keyname);
-#endif
+ }
+ else
+ keycode = _pepper_devicemgr_keyname_to_keycode(pepper_devicemgr->keymap_list, keyname);
ret = devicemgr_input_generator_generate_key(pepper_devicemgr->devicemgr, keycode, pressed);
PEPPER_CHECK(ret == TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE, goto failed, "Failed to generate key(name: %s, code: %d), ret: %d\n", keyname, keycode, ret);
pepper_devicemgr, _pepper_devicemgr_cb_unbind);
}
+PEPPER_API void
+pepper_devicemgr_xkb_enable(pepper_devicemgr_t *pepper_devicemgr)
+{
+ if (pepper_devicemgr->xkb_enabled) return;
+
+ pepper_devicemgr->xkb_enabled = PEPPER_TRUE;
+ pepper_devicemgr->listener_seat_keyboard_add = pepper_object_add_event_listener((pepper_object_t *)pepper_devicemgr->seat,
+ PEPPER_EVENT_SEAT_KEYBOARD_ADD,
+ 0, _pepper_devicemgr_handle_seat_keyboard_add, pepper_devicemgr);
+}
+
PEPPER_API pepper_devicemgr_t *
pepper_devicemgr_create(pepper_compositor_t *compositor, pepper_seat_t *seat)
{
pepper_devicemgr->compositor = compositor;
pepper_devicemgr->seat = seat;
+ pepper_devicemgr->xkb_enabled = PEPPER_FALSE;
+ pepper_devicemgr->xkb_info = NULL;
+
pepper_devicemgr->listener_input_device_add = pepper_object_add_event_listener((pepper_object_t *)pepper_devicemgr->compositor,
PEPPER_EVENT_COMPOSITOR_INPUT_DEVICE_ADD,
0, _pepper_devicemgr_handle_input_device_add, pepper_devicemgr);
-#ifdef _F_DEVICEMGR_XKB
- pepper_devicemgr->listener_seat_keyboard_add = pepper_object_add_event_listener((pepper_object_t *)pepper_devicemgr->seat,
- PEPPER_EVENT_SEAT_KEYBOARD_ADD,
- 0, _pepper_devicemgr_handle_seat_keyboard_add, pepper_devicemgr);
-#endif
-
pepper_list_init(&pepper_devicemgr->resources);
global = wl_global_create(display, &tizen_input_device_manager_interface, 2, pepper_devicemgr, _pepper_devicemgr_cb_bind);
PEPPER_API void pepper_devicemgr_destroy(pepper_devicemgr_t *pepper_devicemgr);
PEPPER_API void pepper_devicemgr_keymap_set(pepper_devicemgr_t *pepper_devicemgr, pepper_list_t *list);
+PEPPER_API void pepper_devicemgr_xkb_enable(pepper_devicemgr_t *pepper_devicemgr);
#include <Ecore_Input.h>
#include <wayland-tbm-client.h>
#include <tbm_surface_internal.h>
+#include <efl_util.h>
#define MAX_STR 1024
typedef struct app_data app_data_t;
typedef enum keygrab_type keygrab_type_e;
+typedef enum key_type key_type_e;
struct app_data
{
struct wayland_tbm_client *wl_tbm_client;
tbm_surface_queue_h tbm_queue;
int last_serial;
+
+ efl_util_inputgen_h inputgen;
};
enum keygrab_type
KEYGRAB_TYPE_EXCLUSIVE
};
+enum key_type
+{
+ KEY_UP = 0,
+ KEY_DOWN,
+ KEY_ALL
+};
+
static Eina_Array *_ecore_event_hdls;
static int KEY_WL_BUFFER = 0;
buffer_release
};
+static char *
+_eflutil_error_to_string(int type)
+{
+ switch (type) {
+ case EFL_UTIL_ERROR_NONE:
+ return "none";
+ case EFL_UTIL_ERROR_INVALID_PARAMETER:
+ return "invalid parameter";
+ case EFL_UTIL_ERROR_OUT_OF_MEMORY:
+ return "out of memory";
+ case EFL_UTIL_ERROR_PERMISSION_DENIED:
+ return "permission denied";
+ case EFL_UTIL_ERROR_NO_SUCH_DEVICE:
+ return "no such device";
+ case EFL_UTIL_ERROR_INVALID_OPERATION:
+ return "invalid operation";
+ case EFL_UTIL_ERROR_NOT_SUPPORTED:
+ return "not supported";
+ case EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE:
+ return "not supported window type";
+ case EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL:
+ return "screenshot init fail";
+ case EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL:
+ return "screenshot execution fail";
+ case EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE:
+ return "no resource available";
+ default:
+ return "Unknown";
+ }
+}
+
static void
_update_window(app_data_t *client)
{
}
static void
+_inputgen_init(app_data_t *client)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (client->inputgen) {
+ printf("Input generator is already initialized\n");
+ return;
+ }
+
+ client->inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ if (!client->inputgen) {
+ ret = get_last_result();
+ printf("Failed to initialize input generator.(result: %s)\n", _eflutil_error_to_string(ret));
+ }
+}
+
+static void
+_inputgen_deinit(app_data_t *client)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (!client->inputgen) {
+ printf("Input generator is not initialized\n");
+ return;
+ }
+
+ ret = efl_util_input_deinitialize_generator(client->inputgen);
+ if (ret != EFL_UTIL_ERROR_NONE) {
+ printf("Failed to deinitialize input generator.(result: %s)\n", _eflutil_error_to_string(ret));
+ return;
+ }
+ client->inputgen = NULL;
+}
+
+static void
+_inputgen_key(app_data_t *client, char *name, int type)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ ret = efl_util_input_generate_key(client->inputgen, name, type);
+ if (ret != EFL_UTIL_ERROR_NONE) printf("Failed to generate key %s(result: %s)\n", type?"down":"up", _eflutil_error_to_string(ret));
+}
+
+
+static void
+_key_gen(app_data_t *client, char *name, int type)
+{
+ printf("name: %s, type: %d\n", name, type);
+
+ if (!client->inputgen) {
+ printf("Input generator is not initialized\n");
+ return;
+ }
+ if (!name) {
+ printf("Invalid key name\n");
+ return;
+ }
+
+ if (type == KEY_ALL) {
+ _inputgen_key(client, name, 1);
+ _inputgen_key(client, name, 0);
+ }
+ else {
+ _inputgen_key(client, name, !!type);
+ }
+}
+
+static void
_usage(void)
{
- printf(" Supported commands: grab (Grab a key)\n");
- printf(" : ungrab (Ungrab a key)\n");
- printf(" : hide (Hide current window)\n");
- printf(" : show (Show current window)\n");
- printf(" : help (Print this help text)\n");
- printf(" : update(update current window)\n");
- printf(" : q/quit (Quit program)\n");
+ printf(" Supported commands: grab (Grab a key)\n");
+ printf(" : ungrab (Ungrab a key)\n");
+ printf(" : hide (Hide current window)\n");
+ printf(" : show (Show current window)\n");
+ printf(" : help (Print this help text)\n");
+ printf(" : update (update current window)\n");
+ printf(" : inputgen (input Generator)\n");
+ printf(" : q/quit (Quit program)\n");
printf("grab [key_name] {grab_type}\n");
printf(" : grab_type:\n");
printf(" - default: shared\n");
printf("ungrab [key_name]\n");
printf(" : ex> ungrab XF86Back\n");
printf("\n");
+ printf("inputgen [options...]\n");
+ printf(" : options:\n");
+ printf(" - init: init generator\n");
+ printf(" - deinit: deinit generator\n");
+ printf(" - key: generate key event\n");
+ printf(" inputgen key [keyname] {type}\n");
+ printf(" - keyname: keyname (ex> XF86Back)\n");
+ printf(" - type: 1: press / 0: release (default: press/release)\n");
+ printf(" : ex> inputgen init\n");
+ printf(" : ex> inputgen key XF86Back / inputgen key XF86Back 1\n");
+ printf(" : ex> inputgen deinit\n");
+ printf("\n");
printf("* Actions *\n");
int count = 0;
char key_name[MAX_STR] = {0, };
int grab_mode = KEYGRAB_TYPE_SHARED;
+ int key_type = KEY_ALL;
while ((c = getchar()) != EOF) {
if (c == '\n') break;
_update_window(client);
printf("update window\n");
}
+ else if (!strncmp(tmp, "inputgen", sizeof("inputgen"))) {
+ tmp = strtok_r(NULL, " ", &buf_ptr);
+ if (tmp) {
+ if (!strncmp(tmp, "init", sizeof("init"))) {
+ _inputgen_init(client);
+ }
+ else if (!strncmp(tmp, "deinit", sizeof("deinit"))) {
+ _inputgen_deinit(client);
+ }
+ else if (!strncmp(tmp, "key", sizeof("key"))) {
+ while (tmp) {
+ tmp = strtok_r(NULL, " ", &buf_ptr);
+ if (tmp) {
+ switch (count) {
+ case 0:
+ strncpy(key_name, tmp, MAX_STR - 1);
+ break;
+ case 1:
+ key_type = atoi(tmp);
+ break;
+ default:
+ break;
+ }
+ }
+ count++;
+ }
+ _key_gen(client, key_name, key_type);
+ }
+ else {
+ printf("invalid arguments\n");
+ _usage();
+ }
+ }
+ }
else {
printf("Invalid arguments\n");
_usage();
socket_name = getenv("WAYLAND_DISPLAY");
- if (!socket_name)
- socket_name = "wayland-0";
+ if (!socket_name)
+ socket_name = "wayland-0";
client = (app_data_t *)calloc(1, sizeof(app_data_t));
ERROR_CHECK(client, goto shutdown, "Failed to allocate memory for app_data_t");
projects / platform / core / uifw / pepper.git / commitdiff