NEWT/Android: Fix BACK button implementation, use different KeyCode mappings and allowing native action to be suppressed.

- Don't trust soft-kbd visibility state, but perform invisible action. If the latter
  was successful - soft-kbd was visible before.

- Map BACK to VK_KEYBOARD_INVISIBLE and propagate it,
  if soft-kbd was visible before.
  No native default action is performed.

- Map BACK to VK_ESCAPE event and propagate it,
  if soft-kbd was invisible _and_ an activity was registered via registerActivity(Activity),
  i.e. by NewtBaseActivity.
  Otherwise proceed w/ default action (-> activity.finish()).

- If the KeyListener consumed the [EVENT_KEY_RELEASED, VK_ESCAPE] event,
  it will be suppressed and no default action performed.
  This allows applications to have a custom 'ESCAPE' or 'BACK' handling.
  Otherwise (not consumed) the default action is performed.

5 files changed, 146 insertions, 24 deletions

diff --git a/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java b/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
index 67bc73652..12a2e3dc2 100644
--- a/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
+++ b/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
@@ -137,7 +137,7 @@ public class NEWTEvent extends java.util.EventObject {
         if(null == sb) {
             sb = new StringBuilder();
         }
-        return sb.append("NEWTEvent[source:").append(getSource().getClass().getName()).append(", when:").append(getWhen()).append(" d ").append((System.currentTimeMillis()-getWhen())).append("ms]");
+        return sb.append("NEWTEvent[source:").append(getSource().getClass().getName()).append("consumed ").append(isConsumed()).append(", when:").append(getWhen()).append(" d ").append((System.currentTimeMillis()-getWhen())).append("ms]");
     }
 
     public static String toHexString(short hex) {
diff --git a/src/newt/classes/jogamp/newt/WindowImpl.java b/src/newt/classes/jogamp/newt/WindowImpl.java
index e8dc0d7d7..e1636ffcd 100644
--- a/src/newt/classes/jogamp/newt/WindowImpl.java
+++ b/src/newt/classes/jogamp/newt/WindowImpl.java
@@ -1625,6 +1625,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         windowHandle = handle;
     }
 
+    @Override
     public void runOnEDTIfAvail(boolean wait, final Runnable task) {
         if( windowLock.isOwner( Thread.currentThread() ) ) {
             task.run();
@@ -1650,14 +1651,17 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }
     };
 
+    @Override
     public final boolean hasFocus() {
         return hasFocus;
     }
 
+    @Override
     public void requestFocus() {
         requestFocus(true);
     }
 
+    @Override
     public void requestFocus(boolean wait) {
         requestFocus(wait /* wait */, false /* skipFocusAction */, brokenFocusChange /* force */);
     }
@@ -1680,6 +1684,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }        
     }
     
+    @Override
     public void setFocusAction(FocusRunnable focusAction) {
         this.focusAction = focusAction;
     }
@@ -1704,6 +1709,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         brokenFocusChange = v;
     }
     
+    @Override
     public void setKeyboardFocusHandler(KeyListener l) {
         keyboardFocusHandler = l;
     }
@@ -1737,11 +1743,13 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }
     }
 
+    @Override
     public void setPosition(int x, int y) {
         autoPosition = false;
         runOnEDTIfAvail(true, new SetPositionAction(x, y));
     }
     
+    @Override
     public void setTopLevelPosition(int x, int y) {
         setPosition(x + getInsets().getLeftWidth(), y + getInsets().getTopHeight());
     }
@@ -1848,6 +1856,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     }
     private final FullScreenAction fullScreenAction = new FullScreenAction();
 
+    @Override
     public boolean setFullscreen(boolean fullscreen) {
         synchronized(fullScreenAction) {
             if( fullScreenAction.init(fullscreen) ) {               
@@ -1921,12 +1930,14 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     // Child Window Management
     // 
 
+    @Override
     public final boolean removeChild(NativeWindow win) {
         synchronized(childWindowsLock) {
             return childWindows.remove(win);
         }
     }
 
+    @Override
     public final boolean addChild(NativeWindow win) {
         if (win == null) {
             return false;
@@ -1952,12 +1963,14 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }
     }
 
+    @Override
     public void enqueueEvent(boolean wait, com.jogamp.newt.event.NEWTEvent event) {
         if(isNativeValid()) {
             ((DisplayImpl)screen.getDisplay()).enqueueEvent(wait, event);
         }
     }
 
+    @Override
     public boolean consumeEvent(NEWTEvent e) {
         switch(e.getEventType()) {
             // special repaint treatment
@@ -2009,18 +2022,22 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     //
     // SurfaceUpdatedListener Support
     //
+    @Override
     public void addSurfaceUpdatedListener(SurfaceUpdatedListener l) {
         surfaceUpdatedHelper.addSurfaceUpdatedListener(l);
     }
 
+    @Override
     public void addSurfaceUpdatedListener(int index, SurfaceUpdatedListener l) throws IndexOutOfBoundsException {
         surfaceUpdatedHelper.addSurfaceUpdatedListener(index, l);
     }
 
+    @Override
     public void removeSurfaceUpdatedListener(SurfaceUpdatedListener l) {
         surfaceUpdatedHelper.removeSurfaceUpdatedListener(l);
     }
 
+    @Override
     public void surfaceUpdated(Object updater, NativeSurface ns, long when) {
         surfaceUpdatedHelper.surfaceUpdated(updater, ns, when);
     }
@@ -2149,11 +2166,12 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }
     }
 
-
+    @Override
     public void addMouseListener(MouseListener l) {
         addMouseListener(-1, l);
     }
 
+    @Override
     public void addMouseListener(int index, MouseListener l) {
         if(l == null) {
             return;
@@ -2167,6 +2185,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         mouseListeners = clonedListeners;
     }
 
+    @Override
     public void removeMouseListener(MouseListener l) {
         if (l == null) {
             return;
@@ -2177,6 +2196,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         mouseListeners = clonedListeners;
     }
 
+    @Override
     public MouseListener getMouseListener(int index) {
         @SuppressWarnings("unchecked")
         ArrayList<MouseListener> clonedListeners = (ArrayList<MouseListener>) mouseListeners.clone();
@@ -2186,6 +2206,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         return clonedListeners.get(index);
     }
 
+    @Override
     public MouseListener[] getMouseListeners() {
         return mouseListeners.toArray(new MouseListener[mouseListeners.size()]);
     }
@@ -2267,26 +2288,31 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         enqueueEvent(wait, new KeyEvent(eventType, this, System.currentTimeMillis(), modifiers | mouseButtonModMask, keyCode, keySym, keyChar) );
     }
     
-    public void addKeyListener(KeyListener l) {
-        addKeyListener(-1, l);
-    }
-
+    @Override
     public final void setKeyboardVisible(boolean visible) {
         if(isNativeValid()) {
             // We don't skip the impl. if it seems that there is no state change,
             // since we cannot assume the impl. reliably gives us it's current state. 
-            final boolean n = setKeyboardVisibleImpl(visible);
+            final boolean ok = setKeyboardVisibleImpl(visible);
             if(DEBUG_IMPLEMENTATION || DEBUG_KEY_EVENT) {
-                System.err.println("setKeyboardVisible(native): visible "+keyboardVisible+" -> "+visible +" -> "+n);
+                System.err.println("setKeyboardVisible(native): visible "+keyboardVisible+" -- op[visible:"+visible +", ok "+ok+"] -> "+(visible && ok));
             }
-            keyboardVisible = n;
+            keyboardVisibilityChanged( visible && ok );
         } else {
-            keyboardVisible = visible; // earmark for creation
+            keyboardVisibilityChanged( visible ); // earmark for creation
         }
     }
+    @Override
     public final boolean isKeyboardVisible() {
         return keyboardVisible;
-    }    
+    }
+    /** 
+     * Returns <code>true</code> if operation was successful, otherwise <code>false</code>.
+     * <p>
+     * We assume that a failed invisible operation is due to an already invisible keyboard,
+     * hence even if an invisible operation failed, the keyboard is considered invisible!  
+     * </p> 
+     */ 
     protected boolean setKeyboardVisibleImpl(boolean visible) {
         return false; // nop
     }
@@ -2301,6 +2327,12 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     }
     protected boolean keyboardVisible = false;
     
+    @Override
+    public void addKeyListener(KeyListener l) {
+        addKeyListener(-1, l);
+    }
+
+    @Override
     public void addKeyListener(int index, KeyListener l) {
         if(l == null) {
             return;
@@ -2314,6 +2346,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         keyListeners = clonedListeners;
     }
 
+    @Override
     public void removeKeyListener(KeyListener l) {
         if (l == null) {
             return;
@@ -2324,6 +2357,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         keyListeners = clonedListeners;
     }
 
+    @Override
     public KeyListener getKeyListener(int index) {
         @SuppressWarnings("unchecked")
         ArrayList<KeyListener> clonedListeners = (ArrayList<KeyListener>) keyListeners.clone();
@@ -2333,6 +2367,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         return clonedListeners.get(index);
     }
 
+    @Override
     public KeyListener[] getKeyListeners() {
         return keyListeners.toArray(new KeyListener[keyListeners.size()]);
     }
@@ -2404,6 +2439,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     //
     // WindowListener/Event Support
     //
+    @Override
     public void sendWindowEvent(int eventType) {
         consumeWindowEvent( new WindowEvent((short)eventType, this, System.currentTimeMillis()) ); // FIXME
     }
@@ -2412,10 +2448,12 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         enqueueEvent( wait, new WindowEvent((short)eventType, this, System.currentTimeMillis()) ); // FIXME
     }
 
+    @Override
     public void addWindowListener(WindowListener l) {
         addWindowListener(-1, l);
     }
 
+    @Override
     public void addWindowListener(int index, WindowListener l) 
         throws IndexOutOfBoundsException
     {
@@ -2431,6 +2469,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         windowListeners = clonedListeners;
     }
 
+    @Override
     public final void removeWindowListener(WindowListener l) {
         if (l == null) {
             return;
@@ -2441,6 +2480,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         windowListeners = clonedListeners;
     }
 
+    @Override
     public WindowListener getWindowListener(int index) {
         @SuppressWarnings("unchecked")
         ArrayList<WindowListener> clonedListeners = (ArrayList<WindowListener>) windowListeners.clone();
@@ -2450,6 +2490,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         return clonedListeners.get(index);
     }
 
+    @Override
     public WindowListener[] getWindowListeners() {
         return windowListeners.toArray(new WindowListener[windowListeners.size()]);
     }
@@ -2676,6 +2717,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         return destroyed;
     }
 
+    @Override
     public void windowRepaint(int x, int y, int width, int height) {
         windowRepaint(false, x, y, width, height); 
     }
diff --git a/src/newt/classes/jogamp/newt/driver/android/NewtBaseActivity.java b/src/newt/classes/jogamp/newt/driver/android/NewtBaseActivity.java
index 6bc81a555..726793768 100644
--- a/src/newt/classes/jogamp/newt/driver/android/NewtBaseActivity.java
+++ b/src/newt/classes/jogamp/newt/driver/android/NewtBaseActivity.java
@@ -126,6 +126,9 @@ public class NewtBaseActivity extends Activity {
     * @see #addContentView(android.view.Window, Window, android.view.ViewGroup.LayoutParams)
     */
    public void registerNEWTWindow(Window newtWindow) {
+       newtWindow = newtWindow.getDelegatedWindow();
+       WindowDriver newtAWindow = (WindowDriver)newtWindow;
+       newtAWindow.registerActivity(getActivity());
        newtWindows.add(newtWindow);
    }
    
diff --git a/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java b/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java
index c5371ae9c..0a253ff9e 100644
--- a/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java
+++ b/src/newt/classes/jogamp/newt/driver/android/WindowDriver.java
@@ -47,12 +47,15 @@ import com.jogamp.common.os.AndroidVersion;
 import com.jogamp.nativewindow.egl.EGLGraphicsDevice;
 import com.jogamp.newt.Screen;
 import com.jogamp.newt.ScreenMode;
+import com.jogamp.newt.event.NEWTEvent;
 
 import jogamp.opengl.egl.EGL;
 import jogamp.opengl.egl.EGLGraphicsConfiguration;
 import jogamp.opengl.egl.EGLGraphicsConfigurationFactory;
 
+import android.app.Activity;
 import android.content.Context;
+import android.content.Intent;
 import android.graphics.PixelFormat;
 import android.os.Bundle;
 import android.os.IBinder;
@@ -205,6 +208,11 @@ public class WindowDriver extends jogamp.newt.WindowImpl implements Callback2 {
     public WindowDriver() {
         reset();
     }
+    
+    public void registerActivity(Activity activity) {
+        this.activity = activity;
+    }
+    protected Activity activity = null;
 
     private final void reset() {
         added2StaticViewGroup = false;
@@ -499,14 +507,15 @@ public class WindowDriver extends jogamp.newt.WindowImpl implements Callback2 {
         if(null != androidView) {
             final InputMethodManager imm = (InputMethodManager) getAndroidView().getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
             final IBinder winid = getAndroidView().getWindowToken();
+            final boolean result;
             if(visible) {
                 // Show soft-keyboard:
-                imm.showSoftInput(androidView, 0, keyboardVisibleReceiver);
+                result = imm.showSoftInput(androidView, 0, keyboardVisibleReceiver);
             } else {
                 // hide keyboard :
-                imm.hideSoftInputFromWindow(winid, 0, keyboardVisibleReceiver);
+                result = imm.hideSoftInputFromWindow(winid, 0, keyboardVisibleReceiver);
             }
-            return visible;
+            return result;
         } else {
             return false; // nop
         }
@@ -588,25 +597,74 @@ public class WindowDriver extends jogamp.newt.WindowImpl implements Callback2 {
         
     protected boolean handleKeyCodeBack(KeyEvent.DispatcherState state, android.view.KeyEvent event) {
         if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
+            Log.d(MD.TAG, "handleKeyCodeBack.0 : "+event);
             state.startTracking(event, this);
         } else if (event.getAction() == KeyEvent.ACTION_UP && !event.isCanceled() && state.isTracking(event)) {
-            if( isKeyboardVisible() ) {
-                keyboardVisibilityChanged(false);
-                enqueueAKey2NKeyUpDown(event);
+            // Since we cannot trust the visibility state 'completly', 
+            // assume an already invisible state if the invisible operation fails. 
+            final boolean wasVisible = setKeyboardVisibleImpl(false);
+            Log.d(MD.TAG, "handleKeyCodeBack.1 : wasVisible "+wasVisible+": "+event);
+            keyboardVisibilityChanged(false);
+            if( wasVisible ) {
+                // event processed, just send invisible event, no activity.finished()
+                enqueueAKey2NKeyUpDown(event, com.jogamp.newt.event.KeyEvent.VK_KEYBOARD_INVISIBLE);
+                return true;
+            } else if( null != activity ) {
+                // process event on our own, since we have an activity to call finish()
+                // and decide in overriden consumeKeyEvent(..) whether we suppress or proceed w/ activity.finish().
+                enqueueAKey2NKeyUpDown(event, com.jogamp.newt.event.KeyEvent.VK_ESCAPE);
+                return true;
             } else {
-                Log.d(MD.TAG, "handleKeyCodeBack : "+event);
+                Log.d(MD.TAG, "handleKeyCodeBack.X1 : "+event);
                 windowDestroyNotify(true);
+                // -> default BACK action, usually activity.finish() 
             }
         }
-        return false; // cont. processing
+        return false; // continue w/ further processing
+    }
+    protected boolean handleKeyCodeHome(KeyEvent.DispatcherState state, android.view.KeyEvent event) {
+        if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
+            Log.d(MD.TAG, "handleKeyCodeHome.0 : "+event);
+            state.startTracking(event, this);
+        } else if (event.getAction() == KeyEvent.ACTION_UP && !event.isCanceled() && state.isTracking(event)) {
+            Log.d(MD.TAG, "handleKeyCodeHome.1 : "+event);
+            enqueueAKey2NKeyUpDown(event, com.jogamp.newt.event.KeyEvent.VK_HOME);
+            return true; // we handle further processing
+        }
+        return false; // continue w/ further processing
     }
-    private void enqueueAKey2NKeyUpDown(android.view.KeyEvent aEvent) {
-        final com.jogamp.newt.event.KeyEvent eDown = AndroidNewtEventFactory.createKeyEvent(aEvent, com.jogamp.newt.event.KeyEvent.EVENT_KEY_PRESSED, this, true);
-        final com.jogamp.newt.event.KeyEvent eUp = AndroidNewtEventFactory.createKeyEvent(aEvent, com.jogamp.newt.event.KeyEvent.EVENT_KEY_RELEASED, this, true);
+    private void enqueueAKey2NKeyUpDown(android.view.KeyEvent aEvent, short newtKeyCode) {
+        final com.jogamp.newt.event.KeyEvent eDown = AndroidNewtEventFactory.createKeyEvent(aEvent, newtKeyCode, com.jogamp.newt.event.KeyEvent.EVENT_KEY_PRESSED, this);
+        final com.jogamp.newt.event.KeyEvent eUp = AndroidNewtEventFactory.createKeyEvent(aEvent, newtKeyCode, com.jogamp.newt.event.KeyEvent.EVENT_KEY_RELEASED, this);
         enqueueEvent(false, eDown);
         enqueueEvent(false, eUp);
     }
     
+    // private GLEventListenerState glels = null;
+    
+    @Override
+    protected void consumeKeyEvent(com.jogamp.newt.event.KeyEvent e) {
+        super.consumeKeyEvent(e); // consume event, i.e. call all KeyListener
+        if( com.jogamp.newt.event.KeyEvent.EVENT_KEY_RELEASED == e.getEventType() && !e.isConsumed() ) {
+            if( com.jogamp.newt.event.KeyEvent.VK_ESCAPE == e.getKeyCode() ) {
+                Log.d(MD.TAG, "handleKeyCodeBack.X2 : "+e);
+                activity.finish();
+            } else if( com.jogamp.newt.event.KeyEvent.VK_HOME == e.getKeyCode() ) {
+                Log.d(MD.TAG, "handleKeyCodeHome.X2 : "+e);
+                triggerHome();
+            }
+        }
+    }    
+    private void triggerHome() {
+       Context ctx = StaticContext.getContext();
+       if(null == ctx) {
+           throw new NativeWindowException("No static [Application] Context has been set. Call StaticContext.setContext(Context) first.");
+       }
+       Intent showOptions = new Intent(Intent.ACTION_MAIN);
+       showOptions.addCategory(Intent.CATEGORY_HOME);
+       ctx.startActivity(showOptions);
+    }
+    
     private boolean added2StaticViewGroup;
     private MSurfaceView androidView;
     private int nativeFormat; // chosen current native PixelFormat (suitable for EGL)
@@ -625,11 +683,17 @@ public class WindowDriver extends jogamp.newt.WindowImpl implements Callback2 {
 
         @Override
         public boolean onKeyPreIme(int keyCode, KeyEvent event) {
+            Log.d(MD.TAG, "onKeyPreIme : "+event);
             if ( event.getKeyCode() == KeyEvent.KEYCODE_BACK ) {
                 final KeyEvent.DispatcherState state = getKeyDispatcherState();
                 if (state != null) {
                     return handleKeyCodeBack(state, event);
                 }
+            } else if ( event.getKeyCode() == KeyEvent.KEYCODE_HOME ) {
+                final KeyEvent.DispatcherState state = getKeyDispatcherState();
+                if (state != null) {
+                    return handleKeyCodeHome(state, event);
+                }
             }
             return false; // cont. processing
         }        
diff --git a/src/newt/classes/jogamp/newt/driver/android/event/AndroidNewtEventFactory.java b/src/newt/classes/jogamp/newt/driver/android/event/AndroidNewtEventFactory.java
index 1f78bd578..5d2333c1f 100644
--- a/src/newt/classes/jogamp/newt/driver/android/event/AndroidNewtEventFactory.java
+++ b/src/newt/classes/jogamp/newt/driver/android/event/AndroidNewtEventFactory.java
@@ -110,7 +110,7 @@ public class AndroidNewtEventFactory {
             case android.view.KeyEvent.KEYCODE_TAB: return com.jogamp.newt.event.KeyEvent.VK_TAB;
             case android.view.KeyEvent.KEYCODE_SPACE: return com.jogamp.newt.event.KeyEvent.VK_SPACE;
             case android.view.KeyEvent.KEYCODE_ENTER: return com.jogamp.newt.event.KeyEvent.VK_ENTER;
-            case android.view.KeyEvent.KEYCODE_DEL: return com.jogamp.newt.event.KeyEvent.VK_DELETE;
+            case android.view.KeyEvent.KEYCODE_DEL: return com.jogamp.newt.event.KeyEvent.VK_BACK_SPACE;
             case android.view.KeyEvent.KEYCODE_MINUS: return com.jogamp.newt.event.KeyEvent.VK_MINUS;
             case android.view.KeyEvent.KEYCODE_EQUALS: return com.jogamp.newt.event.KeyEvent.VK_EQUALS;
             case android.view.KeyEvent.KEYCODE_LEFT_BRACKET: return com.jogamp.newt.event.KeyEvent.VK_LEFT_PARENTHESIS;
@@ -128,11 +128,16 @@ public class AndroidNewtEventFactory {
             case android.view.KeyEvent.KEYCODE_CTRL_RIGHT: return com.jogamp.newt.event.KeyEvent.VK_CONTROL; // ??
             case android.view.KeyEvent.KEYCODE_BACK: 
                 if( inclSysKeys ) {
-                    return com.jogamp.newt.event.KeyEvent.VK_KEYBOARD_INVISIBLE;
+                    // Note that manual mapping is performed, based on the keyboard state.
+                    // I.e. we map to VK_KEYBOARD_INVISIBLE if keyboard was visible and now becomes invisible!
+                    // Otherwise we map to VK_ESCAPE, and if not consumed by user, the application will be terminated.
+                    return com.jogamp.newt.event.KeyEvent.VK_ESCAPE;
                 }
                 break;
             case android.view.KeyEvent.KEYCODE_HOME:
                 if( inclSysKeys ) {
+                    // If not consumed by user, the application will be 'paused',
+                    // i.e. resources (GLEventListener) pulled before surface gets destroyed!
                     return com.jogamp.newt.event.KeyEvent.VK_HOME;
                 }
                 break;
@@ -184,6 +189,14 @@ public class AndroidNewtEventFactory {
         return res;
     }
     
+    public static com.jogamp.newt.event.KeyEvent createKeyEvent(android.view.KeyEvent aEvent, short newtKeyCode, short newtType, com.jogamp.newt.Window newtSource) {
+        final com.jogamp.newt.event.KeyEvent res = createKeyEventImpl(aEvent, newtType, newtKeyCode, newtSource);
+        if(Window.DEBUG_KEY_EVENT) {
+            System.err.println("createKeyEvent2: newtType "+NEWTEvent.toHexString(newtType)+", "+aEvent+" -> "+res);
+        }
+        return res;
+    }
+    
     private static com.jogamp.newt.event.KeyEvent createKeyEventImpl(android.view.KeyEvent aEvent, short newtType, short newtKeyCode, com.jogamp.newt.Window newtSource) {
         if( (short)0 != newtType && (short)0 != newtKeyCode ) {
             final Object src = null==newtSource ? null : newtSource;