[Title] extend the KeyEventData

[Type] enhancement
[Module] Emulator / keyboard
[Priority] major
[Jira#]
[Redmine#]
[Problem]
[Cause]
[Solution] added state mask field
[TestCase]

diff --git a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java
index ce52474..8e51921 100644 (file)
--- a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java
+++ b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java
@@ -655,7 +655,8 @@ public class EmulatorSkin {
 
                                                SkinUtil.trimShell( shell, currentImage );
 
-                                               KeyEventData keyEventData = new KeyEventData( KeyEventType.RELEASED.value(), keyCode, 0 );
+                                               KeyEventData keyEventData = new KeyEventData(
+                                                               KeyEventType.RELEASED.value(), keyCode, 0, 0);
                                                communicator.sendToQEMU( SendCommand.SEND_HARD_KEY_EVENT, keyEventData );
                                        }
 
@@ -711,7 +712,8 @@ public class EmulatorSkin {
                                                        });
                                                }
 
-                                               KeyEventData keyEventData = new KeyEventData( KeyEventType.PRESSED.value(), keyCode, 0 );
+                                               KeyEventData keyEventData = new KeyEventData(
+                                                               KeyEventType.PRESSED.value(), keyCode, 0, 0);
                                                communicator.sendToQEMU( SendCommand.SEND_HARD_KEY_EVENT, keyEventData );
                                        }
                                }
@@ -922,60 +924,70 @@ public class EmulatorSkin {
                        private KeyEvent previous;
                        private boolean disappearEvent = false;
                        private int disappearKeycode = 0;
+                       private int disappearStateMask = 0;
                        private int disappearKeyLocation = 0;
 
                        @Override
                        public void keyReleased( KeyEvent e ) {
-                               if( logger.isLoggable( Level.INFO ) ) {
+                               if ( logger.isLoggable( Level.INFO ) ) {
                                        logger.info( "'" + e.character + "':" + e.keyCode + ":" + e.stateMask + ":" + e.keyLocation );
-                               }else if( logger.isLoggable( Level.FINE ) ) {
+                               } else if ( logger.isLoggable( Level.FINE ) ) {
                                        logger.fine( e.toString() );
                                }
-                               int keyCode = e.keyCode | e.stateMask;
+                               int keyCode = e.keyCode;
+                               int stateMask = e.stateMask;
 
                                previous = null;
-                               
+
                                if( SwtUtil.isWindowsPlatform() && disappearEvent) {
                                        disappearEvent = false;
                                        if (isMetaKey(e) && e.character != '\0') {
                                                logger.info( "send previous release : keycode=" + disappearKeycode +
-                                                               ", disappearKeyLocation=" + disappearKeyLocation);
+                                                               ", stateMask=" + disappearStateMask + ", keyLocation=" + disappearKeyLocation);
 
                                                KeyEventData keyEventData = new KeyEventData(
-                                                               KeyEventType.RELEASED.value(), disappearKeycode, disappearKeyLocation );
-                                               communicator.sendToQEMU( SendCommand.SEND_KEY_EVENT, keyEventData );
+                                                               KeyEventType.RELEASED.value(),
+                                                               disappearKeycode, disappearStateMask, disappearKeyLocation);
+                                               communicator.sendToQEMU(SendCommand.SEND_KEY_EVENT, keyEventData);
 
                                                disappearKeycode = 0;
+                                               disappearStateMask = 0;
                                                disappearKeyLocation = 0;
                                        }
                                }
-                               KeyEventData keyEventData = new KeyEventData( KeyEventType.RELEASED.value(), keyCode, e.keyLocation );
-                               communicator.sendToQEMU( SendCommand.SEND_KEY_EVENT, keyEventData );
+
+                               KeyEventData keyEventData = new KeyEventData(
+                                               KeyEventType.RELEASED.value(), keyCode, stateMask, e.keyLocation);
+                               communicator.sendToQEMU(SendCommand.SEND_KEY_EVENT, keyEventData);
                        }
 
                        @Override
                        public void keyPressed( KeyEvent e ) {
-                               int keyCode = e.keyCode | e.stateMask;
-                               
+                               int keyCode = e.keyCode;
+                               int stateMask = e.stateMask;
+
                                if( SwtUtil.isWindowsPlatform() ) {
-                                       if ( null != previous ) {
-                                               if ( previous.keyCode != e.keyCode ) {
+                                       if (null != previous) {
+                                               if (previous.keyCode != e.keyCode) {
 
-                                                       if ( isMetaKey( previous ) ) {
+                                                       if (isMetaKey(previous)) {
                                                                disappearEvent = true;
                                                                disappearKeycode = keyCode;
+                                                               disappearStateMask = stateMask;
                                                                disappearKeyLocation = e.keyLocation;
                                                        } else {
-                                                               int previousKeyCode = previous.keyCode | previous.stateMask;
-                                                               
+                                                               int previousKeyCode = previous.keyCode;
+                                                               int previousStateMask = previous.stateMask;
+
                                                                if ( logger.isLoggable( Level.INFO ) ) {
                                                                        logger.info( "send previous release : '" + previous.character + "':"
                                                                                        + previous.keyCode + ":" + previous.stateMask + ":" + previous.keyLocation );
                                                                } else if ( logger.isLoggable( Level.FINE ) ) {
                                                                        logger.fine( "send previous release :" + previous.toString() );
                                                                }
-                                                               KeyEventData keyEventData = new KeyEventData( KeyEventType.RELEASED.value(), previousKeyCode,
-                                                                               previous.keyLocation );
+
+                                                               KeyEventData keyEventData = new KeyEventData(KeyEventType.RELEASED.value(),
+                                                                               previousKeyCode, previousStateMask, previous.keyLocation);
                                                                communicator.sendToQEMU( SendCommand.SEND_KEY_EVENT, keyEventData );
                                                        }
 
@@ -990,7 +1002,9 @@ public class EmulatorSkin {
                                } else if ( logger.isLoggable( Level.FINE ) ) {
                                        logger.fine( e.toString() );
                                }
-                               KeyEventData keyEventData = new KeyEventData( KeyEventType.PRESSED.value(), keyCode, e.keyLocation );
+
+                               KeyEventData keyEventData = new KeyEventData(
+                                               KeyEventType.PRESSED.value(), keyCode, stateMask, e.keyLocation);
                                communicator.sendToQEMU( SendCommand.SEND_KEY_EVENT, keyEventData );
                        }
 
@@ -1000,13 +1014,15 @@ public class EmulatorSkin {
 
        }
 
-       private boolean isMetaKey( KeyEvent event ) {
-               if( SWT.CTRL == event.keyCode || SWT.ALT == event.keyCode || SWT.SHIFT == event.keyCode ) {
+       private boolean isMetaKey(KeyEvent event) {
+               if (SWT.CTRL == event.keyCode ||
+                               SWT.ALT == event.keyCode ||
+                               SWT.SHIFT == event.keyCode) {
                        return true;
                }
                return false;
        }
-       
+
        private void removeCanvasListeners() {
 
 //             if ( null != canvasDragDetectListener ) {

diff --git a/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/sock/data/KeyEventData.java b/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/sock/data/KeyEventData.java
index bb4260f..ef8fd2c 100644 (file)
--- a/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/sock/data/KeyEventData.java
+++ b/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/sock/data/KeyEventData.java
@@ -39,11 +39,13 @@ public class KeyEventData extends AbstractSendData {
 
        int eventType;
        int keycode;
+       int stateMask;
        int keyLocation;
 
-       public KeyEventData(int eventType, int keycode, int keyLocation) {
+       public KeyEventData(int eventType, int keycode, int stateMask, int keyLocation) {
                this.eventType = eventType;
                this.keycode = keycode;
+               this.stateMask = stateMask;
                this.keyLocation = keyLocation;
        }
        
@@ -51,6 +53,7 @@ public class KeyEventData extends AbstractSendData {
        protected void write() throws IOException {
                writeInt(eventType);
                writeInt(keycode);
+               writeInt(stateMask);
                writeInt(keyLocation);
        }
        
@@ -61,6 +64,8 @@ public class KeyEventData extends AbstractSendData {
                builder.append(eventType);
                builder.append(", keycode=");
                builder.append(keycode);
+               builder.append(", stateMask=");
+               builder.append(stateMask);
                builder.append(", keyLocation=");
                builder.append(keyLocation);
                builder.append("]");

diff --git a/tizen/src/skin/maruskin_keymap.c b/tizen/src/skin/maruskin_keymap.c
index fdf9d24..88f113d 100644 (file)
--- a/tizen/src/skin/maruskin_keymap.c
+++ b/tizen/src/skin/maruskin_keymap.c
@@ -36,9 +36,10 @@
 MULTI_DEBUG_CHANNEL(qemu, skin_keymap);
 
 
-int javakeycode_to_scancode(int java_keycode, int event_type, int key_location)
+int javakeycode_to_scancode(
+    int event_type, int java_keycode, int state_mask, int key_location)
 {
-    int state_mask = java_keycode & JAVA_KEYCODE_BIT;
+    int state = java_keycode & JAVA_KEYCODE_BIT;
     int vk = java_keycode & JAVA_KEY_MASK;
 
     int ctrl_mask = java_keycode & JAVA_KEYCODE_BIT_CTRL;
@@ -47,7 +48,7 @@ int javakeycode_to_scancode(int java_keycode, int event_type, int key_location)
 
 
     /* CapsLock & NumLock key processing */
-    if (state_mask != 0) {
+    if (state != 0) {
         if (vk == JAVA_KEY_CAPS_LOCK) {
             if (event_type == KEY_PRESSED) {
                 set_emul_caps_lock_state(get_emul_caps_lock_state() ^ 1); //toggle
@@ -62,13 +63,19 @@ int javakeycode_to_scancode(int java_keycode, int event_type, int key_location)
     }
     /* check CapsLock & NumLock key sync */
     if (event_type == KEY_PRESSED) {
-        if (get_emul_caps_lock_state() != get_host_lock_key_state(HOST_CAPSLOCK_KEY)) {
+        int caps_lock = -1;
+        int num_lock = -1;
+
+        caps_lock = get_host_lock_key_state(HOST_CAPSLOCK_KEY);
+        num_lock = get_host_lock_key_state(HOST_NUMLOCK_KEY);
+
+        if (caps_lock != -1 && get_emul_caps_lock_state() != caps_lock) {
             kbd_put_keycode(58);
             kbd_put_keycode(58 | 0x80);
             set_emul_caps_lock_state(get_emul_caps_lock_state() ^ 1);
             INFO("qemu CapsLock state was synchronized with host key value (%d)\n", get_emul_caps_lock_state());
         }
-        if (get_emul_num_lock_state() != get_host_lock_key_state(HOST_NUMLOCK_KEY)) {
+        if (num_lock != -1 && get_emul_num_lock_state() != num_lock) {
             kbd_put_keycode(69);
             kbd_put_keycode(69 | 0x80);
             set_emul_num_lock_state(get_emul_num_lock_state() ^ 1);
@@ -105,7 +112,7 @@ int javakeycode_to_scancode(int java_keycode, int event_type, int key_location)
         }
     }
 
-    if (state_mask != 0)
+    if (state != 0)
     { //non-character keys
         if (vk >= JAVA_KEY_F1 && vk <= JAVA_KEY_F20) { //function keys
             vk += 255;

diff --git a/tizen/src/skin/maruskin_keymap.h b/tizen/src/skin/maruskin_keymap.h
index cd2c96a..e3f3e2e 100644 (file)
--- a/tizen/src/skin/maruskin_keymap.h
+++ b/tizen/src/skin/maruskin_keymap.h
@@ -230,6 +230,7 @@ static const int vkkey2scancode[KEY_MAX] = {
     ['?'] = 53 | SHIFT,
 };
 
-int javakeycode_to_scancode(int java_keycode, int event_type, int key_location);
+int javakeycode_to_scancode(
+    int event_type, int java_keycode, int state_mask, int key_location);
 
 #endif /* MARUSKIN_KEYMAP_H_ */

diff --git a/tizen/src/skin/maruskin_operation.c b/tizen/src/skin/maruskin_operation.c
index 68fe7c7..b7cfb80 100644 (file)
--- a/tizen/src/skin/maruskin_operation.c
+++ b/tizen/src/skin/maruskin_operation.c
@@ -146,9 +146,12 @@ void do_mouse_event(int button_type, int event_type,
 #endif
 }
 
-void do_key_event( int event_type, int keycode, int key_location )
+void do_key_event(int event_type, int keycode, int state_mask, int key_location)
 {
-    TRACE( "key_event event_type:%d, keycode:%d, key_location:%d\n", event_type, keycode, key_location );
+    int scancode = -1;
+
+    TRACE("key_event event_type:%d, keycode:%d, state_mask:%d, key_location:%d\n",
+        event_type, keycode, state_mask, key_location);
 
 #ifndef USE_SHM
     //is multi-touch mode ?
@@ -156,26 +159,26 @@ void do_key_event( int event_type, int keycode, int key_location )
         if (keycode == JAVA_KEYCODE_BIT_CTRL) {
             if (KEY_PRESSED == event_type) {
                 get_emul_multi_touch_state()->multitouch_enable = 1;
-                INFO("multi-touch enabled = A\n");
+                INFO("1)multi-touch enabled = A\n");
             } else if (KEY_RELEASED == event_type) {
                 get_emul_multi_touch_state()->multitouch_enable = 0;
                 clear_finger_slot();
-                INFO("multi-touch disabled\n");
+                INFO("1)multi-touch disabled\n");
             }
         } else if (keycode == (JAVA_KEYCODE_NO_FOCUS | JAVA_KEYCODE_BIT_CTRL)) {
             //release ctrl key when dragging
             if (KEY_RELEASED == event_type) {
                 get_emul_multi_touch_state()->multitouch_enable = 0;
                 clear_finger_slot();
-                INFO("multi-touch disabled\n");
+                INFO("2)multi-touch disabled\n");
             }
         } else if (keycode == (JAVA_KEYCODE_BIT_SHIFT | JAVA_KEYCODE_BIT_CTRL)) {
             if (KEY_PRESSED == event_type) {
                 get_emul_multi_touch_state()->multitouch_enable = 2;
-                INFO("multi-touch enabled = B\n");
+                INFO("2)multi-touch enabled = B\n");
             } else if (KEY_RELEASED == event_type) {
                 get_emul_multi_touch_state()->multitouch_enable = 1;
-                INFO("multi-touch enabled = A\n");
+                INFO("2)multi-touch enabled = A\n");
             }
         }
     }
@@ -185,7 +188,7 @@ void do_key_event( int event_type, int keycode, int key_location )
         return;
     }
 
-    int scancode = javakeycode_to_scancode(keycode, event_type, key_location);
+    scancode = javakeycode_to_scancode(event_type, keycode, state_mask, key_location);
     TRACE("javakeycode_to_scancode : %d\n", scancode);
 
     if (scancode == -1) {

diff --git a/tizen/src/skin/maruskin_operation.h b/tizen/src/skin/maruskin_operation.h
index cd9e3dc..9fada43 100644 (file)
--- a/tizen/src/skin/maruskin_operation.h
+++ b/tizen/src/skin/maruskin_operation.h
@@ -51,32 +51,32 @@ void start_display(uint64 handle_id, int lcd_size_width, int lcd_size_height, do
 
 void do_mouse_event(int button_type, int event_type, int origin_x, int origin_y, int x, int y, int z);
 
-void do_key_event( int event_type, int keycode, int key_location );
+void do_key_event(int event_type, int keycode, int state_mask, int key_location);
 
-void do_hardkey_event( int event_type, int keycode );
+void do_hardkey_event(int event_type, int keycode);
 
-void do_scale_event( double scale_factor);
+void do_scale_event(double scale_factor);
 
-void do_rotation_event( int rotation_type );
+void do_rotation_event(int rotation_type);
 
-QemuSurfaceInfo* get_screenshot_info( void );
+QemuSurfaceInfo *get_screenshot_info(void);
 
-DetailInfo* get_detail_info( int qemu_argc, char** qemu_argv );
+DetailInfo *get_detail_info(int qemu_argc, char **qemu_argv);
 
-void free_detail_info( DetailInfo* detail_info );
+void free_detail_info(DetailInfo *detail_info);
 
-void free_screenshot_info( QemuSurfaceInfo* );
+void free_screenshot_info(QemuSurfaceInfo *);
 
 void open_shell(void);
 
-void onoff_usb_kbd( int on );
+void onoff_usb_kbd(int on);
 
 void ram_dump(void);
 
-void request_close( void );
+void request_close(void);
 
-void shutdown_qemu_gracefully( void );
+void shutdown_qemu_gracefully(void);
 
-int is_requested_shutdown_qemu_gracefully( void );
+int is_requested_shutdown_qemu_gracefully(void);
 
 #endif /* MARUSKIN_OPERATION_H_ */

diff --git a/tizen/src/skin/maruskin_server.c b/tizen/src/skin/maruskin_server.c
index a55757b..123f8e3 100644 (file)
--- a/tizen/src/skin/maruskin_server.c
+++ b/tizen/src/skin/maruskin_server.c
@@ -664,6 +664,7 @@ static void* run_skin_server( void* args ) {
                     /* keep it consistent with emulator-skin definition */
                     int event_type = 0;
                     int keycode = 0;
+                    int state_mask = 0;
                     int key_location = 0;
 
                     char* p = recvbuf;
@@ -671,13 +672,16 @@ static void* run_skin_server( void* args ) {
                     p += sizeof( event_type );
                     memcpy( &keycode, p, sizeof( keycode ) );
                     p += sizeof( keycode );
+                    memcpy( &state_mask, p, sizeof( state_mask ) );
+                    p += sizeof( state_mask );
                     memcpy( &key_location, p, sizeof( key_location ) );
 
                     event_type = ntohl( event_type );
                     keycode = ntohl( keycode );
+                    state_mask = ntohl( state_mask );
                     key_location = ntohl( key_location );
 
-                    do_key_event( event_type, keycode, key_location );
+                    do_key_event(event_type, keycode, state_mask, key_location);
                     break;
                 }
                 case RECV_HARD_KEY_EVENT: {