headless_debug: implement a keygrab_status

diff --git a/data/scripts/winfo b/data/scripts/winfo
index 106f974..2e02f35 100644 (file)
--- a/data/scripts/winfo
+++ b/data/scripts/winfo
@@ -23,8 +23,8 @@ function usage()
        echo "     protocol_trace_off (turn off wayland protocol trace)"
        echo "     stdout (redirect STDOUT to a file : /run/pepper/stdout.txt)"
        echo "     stderr (redirect STDERR to a file : /run/pepper/stderr.txt)"
-       echo "     keygrab_status (MUST BE IMPLEMENTED)"
-       echo "     topvwins (MSUT BE IMPLEMENTED)"
+       echo "     keygrab_status"
+       echo "     topvwins"
        echo "     connected_clients (display connected clients info : pid, uid, gid, socket fd)"
        echo "     reslist (display resources info of the connected clients"
        echo "     help (display this help message)"

diff --git a/src/bin/headless/debug/debug.c b/src/bin/headless/debug/debug.c
index 6996a87..c45ea7c 100644 (file)
--- a/src/bin/headless/debug/debug.c
+++ b/src/bin/headless/debug/debug.c
@@ -29,6 +29,7 @@
 #include <wayland-server.h>
 #include <wayland-util.h>
 #include <pepper-inotify.h>
+#include <pepper-keyrouter.h>
 
 #define MAX_CMDS       256
 
@@ -278,13 +279,22 @@ _headless_debug_topvwins(headless_debug_t *hdebug, void *data)
        PEPPER_TRACE("==========================================================================================\n");
 }
 
+static void
+_headless_debug_keygrab_status(headless_debug_t *hdebug, void *data)
+{
+       pepper_keyrouter_t *keyrouter;
+
+       keyrouter = headless_input_get_keyrouter(hdebug->compositor);
+       pepper_keyrouter_debug_keygrab_status_print(keyrouter);
+}
+
 static const headless_debug_action_t debug_actions[] =
 {
        { STDOUT_REDIR,  _headless_debug_redir_stdout, NULL },
        { STDERR_REDIR,  _headless_debug_redir_stderr, NULL },
        { PROTOCOL_TRACE_ON,  _headless_debug_protocol_trace_on, _headless_debug_protocol_trace_off },
        { PROTOCOL_TRACE_OFF, _headless_debug_protocol_trace_off, NULL },
-       { KEYGRAB_STATUS, _headless_debug_NOT_supported, NULL },
+       { KEYGRAB_STATUS, _headless_debug_keygrab_status, NULL },
        { TOPVWINS, _headless_debug_topvwins, NULL },
        { CONNECTED_CLIENTS, _headless_debug_connected_clients, NULL },
        { CLIENT_RESOURCES, _headless_debug_connected_clients, NULL },

diff --git a/src/bin/headless/headless_server.h b/src/bin/headless/headless_server.h
index 79c6f1b..ae3f59a 100644 (file)
--- a/src/bin/headless/headless_server.h
+++ b/src/bin/headless/headless_server.h
@@ -43,6 +43,7 @@ PEPPER_API pepper_bool_t headless_input_init(pepper_compositor_t *compositor);
 PEPPER_API void headless_input_deinit(pepper_compositor_t *compositor);
 PEPPER_API void headless_input_set_focus_view(pepper_compositor_t *compositor, pepper_view_t *view);
 PEPPER_API void headless_input_set_top_view(pepper_compositor_t *compositor, pepper_view_t *view);
+PEPPER_API void *headless_input_get_keyrouter(pepper_compositor_t *compositor);
 
 /* APIs for headless_debug */
 PEPPER_API pepper_bool_t headless_debug_init(pepper_compositor_t *compositor);

diff --git a/src/bin/headless/input/input.c b/src/bin/headless/input/input.c
index 9257267..967a247 100644 (file)
--- a/src/bin/headless/input/input.c
+++ b/src/bin/headless/input/input.c
@@ -145,6 +145,16 @@ _cb_handle_inotify_event(uint32_t type, pepper_inotify_event_t *ev, void *data)
        }
 }
 
+PEPPER_API void *
+headless_input_get_keyrouter(pepper_compositor_t *compositor)
+{
+       headless_input_t *hi;
+       hi = pepper_object_get_user_data((pepper_object_t *)compositor, &KEY_INPUT);
+       PEPPER_CHECK(hi, return NULL, "input system is not initialized\n");
+
+       return hi->keyrouter;
+}
+
 void
 headless_input_set_focus_view(pepper_compositor_t *compositor, pepper_view_t *focus_view)
 {

diff --git a/src/lib/keyrouter/keyrouter.c b/src/lib/keyrouter/keyrouter.c
index e51244a..b8d69f1 100644 (file)
--- a/src/lib/keyrouter/keyrouter.c
+++ b/src/lib/keyrouter/keyrouter.c
@@ -24,8 +24,8 @@
 #include "keyrouter-internal.h"
 #include <tizen-extension-server-protocol.h>
 
-static pepper_list_t *
-_keyrouter_grabbed_list_get(keyrouter_t *keyrouter,
+PEPPER_API pepper_list_t *
+keyrouter_grabbed_list_get(keyrouter_t *keyrouter,
                                    int type,
                                    int keycode)
 {
@@ -45,6 +45,28 @@ _keyrouter_grabbed_list_get(keyrouter_t *keyrouter,
        }
 }
 
+PEPPER_API pepper_bool_t
+keyrouter_is_grabbed_key(keyrouter_t *keyrouter, int keycode)
+{
+       pepper_list_t *list;
+
+       PEPPER_CHECK(keyrouter, return PEPPER_FALSE, "keyrouter is invalid.\n");
+
+       list = keyrouter_grabbed_list_get(keyrouter, TIZEN_KEYROUTER_MODE_EXCLUSIVE, keycode);
+       if (list && !pepper_list_empty(list)) return PEPPER_TRUE;
+
+       list = keyrouter_grabbed_list_get(keyrouter, TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, keycode);
+       if (list && !pepper_list_empty(list)) return PEPPER_TRUE;
+
+       list = keyrouter_grabbed_list_get(keyrouter, TIZEN_KEYROUTER_MODE_TOPMOST, keycode);
+       if (list && !pepper_list_empty(list)) return PEPPER_TRUE;
+
+       list = keyrouter_grabbed_list_get(keyrouter, TIZEN_KEYROUTER_MODE_SHARED, keycode);
+       if (list && !pepper_list_empty(list)) return PEPPER_TRUE;
+
+       return PEPPER_FALSE;
+}
+
 static pepper_bool_t
 _keyrouter_list_duplicated_data_check(pepper_list_t *list, void *data)
 {
@@ -68,7 +90,7 @@ _keyrouter_grabbed_check(keyrouter_t *keyrouter,
        pepper_list_t *list = NULL;
        pepper_bool_t res = PEPPER_FALSE;
 
-       list = _keyrouter_grabbed_list_get(keyrouter, type, keycode);
+       list = keyrouter_grabbed_list_get(keyrouter, type, keycode);
        PEPPER_CHECK(list, return PEPPER_FALSE, "keycode(%d) had no list for type(%d)\n", keycode, type);
 
        switch(type)    {
@@ -211,7 +233,7 @@ keyrouter_grab_key(keyrouter_t *keyrouter,
        info->data = data;
        pepper_list_init(&info->link);
 
-       list = _keyrouter_grabbed_list_get(keyrouter, type, keycode);
+       list = keyrouter_grabbed_list_get(keyrouter, type, keycode);
 
        if (!keyrouter->hard_keys[keycode].keycode)
                keyrouter->hard_keys[keycode].keycode = keycode;
@@ -249,7 +271,7 @@ keyrouter_ungrab_key(keyrouter_t *keyrouter,
 
        if (!keyrouter->hard_keys[keycode].keycode) return;
 
-       list = _keyrouter_grabbed_list_get(keyrouter, type, keycode);
+       list = keyrouter_grabbed_list_get(keyrouter, type, keycode);
        PEPPER_CHECK(list, return, "keycode(%d) had no list for type(%d)\n", keycode, type);
 
        _keyrouter_list_remove_data(list, data);

diff --git a/src/lib/keyrouter/keyrouter.h b/src/lib/keyrouter/keyrouter.h
index 51ba2a8..378dfcc 100644 (file)
--- a/src/lib/keyrouter/keyrouter.h
+++ b/src/lib/keyrouter/keyrouter.h
@@ -49,6 +49,9 @@ PEPPER_API int keyrouter_key_process(keyrouter_t *keyrouter, int keycode, int pr
 PEPPER_API void keyrouter_set_focus_client(keyrouter_t *keyrouter, void *focus_client);
 PEPPER_API void keyrouter_set_top_client(keyrouter_t *keyrouter, void *top_client);
 
+PEPPER_API pepper_list_t * keyrouter_grabbed_list_get(keyrouter_t *keyrouter, int keycode, int grab_mode);
+PEPPER_API pepper_bool_t keyrouter_is_grabbed_key(keyrouter_t *keyrouter, int keycode);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/lib/keyrouter/pepper-keyrouter.c b/src/lib/keyrouter/pepper-keyrouter.c
index d529f89..96e2945 100644 (file)
--- a/src/lib/keyrouter/pepper-keyrouter.c
+++ b/src/lib/keyrouter/pepper-keyrouter.c
@@ -212,6 +212,17 @@ _pepper_keyrouter_get_client_from_view(pepper_view_t *view)
        return NULL;
 }
 
+static int
+_pepper_keyrouter_get_pid(struct wl_client *client)
+{
+       pid_t pid = 0;
+       uid_t uid = 0;
+       gid_t gid = 0;
+
+       wl_client_get_credentials(client, &pid, &uid, &gid);
+
+       return pid;
+}
 
 PEPPER_API void
 pepper_keyrouter_set_seat(pepper_keyrouter_t *pepper_keyrouter, pepper_seat_t *seat)
@@ -256,6 +267,54 @@ pepper_keyrouter_set_top_view(pepper_keyrouter_t *pk, pepper_view_t *top_view)
        keyrouter_set_top_client(pk->keyrouter, client);
 }
 
+PEPPER_API void
+pepper_keyrouter_debug_keygrab_status_print(pepper_keyrouter_t *pepper_keyrouter)
+{
+       pepper_list_t *list;
+       int i;
+       keyrouter_key_info_t *grab_data;
+
+       PEPPER_CHECK(pepper_keyrouter, return, "pepper_keyrouter is invalid.\n");
+       PEPPER_CHECK(pepper_keyrouter->keyrouter, return, "keyrouter is invalid.\n");
+
+       for (i = 0; i < KEYROUTER_MAX_KEYS; i++) {
+               if (keyrouter_is_grabbed_key(pepper_keyrouter->keyrouter, i)) {
+                       PEPPER_TRACE("\t[ Keycode: %d ]\n", i);
+                       list = keyrouter_grabbed_list_get(pepper_keyrouter->keyrouter, TIZEN_KEYROUTER_MODE_EXCLUSIVE, i);
+                       if (list && !pepper_list_empty(list)) {
+                               PEPPER_TRACE("\t  == Exclusive Grab ==\n");
+                               pepper_list_for_each(grab_data, list, link) {
+                                       PEPPER_TRACE("\t    client: %p (pid: %d)\n", grab_data->data, _pepper_keyrouter_get_pid(grab_data->data));
+                               }
+                       }
+
+                       list = keyrouter_grabbed_list_get(pepper_keyrouter->keyrouter, TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, i);
+                       if (list && !pepper_list_empty(list)) {
+                               PEPPER_TRACE("\t  == OR_Exclusive Grab ==\n");
+                               pepper_list_for_each(grab_data, list, link) {
+                                       PEPPER_TRACE("\t    client: %p (pid: %d)\n", grab_data->data, _pepper_keyrouter_get_pid(grab_data->data));
+                               }
+                       }
+
+                       list = keyrouter_grabbed_list_get(pepper_keyrouter->keyrouter, TIZEN_KEYROUTER_MODE_TOPMOST, i);
+                       if (list && !pepper_list_empty(list)) {
+                               PEPPER_TRACE("\t  == Top Position Grab ==\n");
+                               pepper_list_for_each(grab_data, list, link) {
+                                       PEPPER_TRACE("\t    client: %p (pid: %d)\n", grab_data->data, _pepper_keyrouter_get_pid(grab_data->data));
+                               }
+                       }
+
+                       list = keyrouter_grabbed_list_get(pepper_keyrouter->keyrouter, TIZEN_KEYROUTER_MODE_SHARED, i);
+                       if (list && !pepper_list_empty(list)) {
+                               PEPPER_TRACE("\t  == Shared Grab ==\n");
+                               pepper_list_for_each(grab_data, list, link) {
+                                       PEPPER_TRACE("\t    client: %p (pid: %d)\n", grab_data->data, _pepper_keyrouter_get_pid(grab_data->data));
+                               }
+                       }
+               }
+       }
+}
+
 static void
 _pepper_keyrouter_key_send(pepper_keyrouter_t *pepper_keyrouter,
                               pepper_seat_t *seat, struct wl_client *client,

diff --git a/src/lib/keyrouter/pepper-keyrouter.h b/src/lib/keyrouter/pepper-keyrouter.h
index b037713..e56d931 100644 (file)
--- a/src/lib/keyrouter/pepper-keyrouter.h
+++ b/src/lib/keyrouter/pepper-keyrouter.h
@@ -34,3 +34,5 @@ PEPPER_API void pepper_keyrouter_set_focus_view(pepper_keyrouter_t *pepper_keyro
 PEPPER_API void pepper_keyrouter_set_top_view(pepper_keyrouter_t *pepper_keyrouter, pepper_view_t *top_view);
 PEPPER_API void pepper_keyrouter_key_process(pepper_keyrouter_t *pepper_keyrouter, unsigned int key, unsigned int state, unsigned int time);
 PEPPER_API void pepper_keyrouter_event_handler(pepper_event_listener_t *listener, pepper_object_t *object, uint32_t id, void *info, void *data);
+
+PEPPER_API void pepper_keyrouter_debug_keygrab_status_print(pepper_keyrouter_t *pepper_keyrouter);