Crash when closing soft keyboard while using native activity

Question

We are developing an indie game for android and would like the user to choose his nickname. We have chosen to use the Native Activity that is provided by the NDK as that seemed to be the easiest way to go.

The first problem we've encountered with the keyboard was that the function ANativeActivity_showSoftInput() seems to do nothing at all (as described e.g. here), so we bring up the keyboard using JNI calls to function:

static void showKeyboard(Activity activity) {
  String s = Context.INPUT_METHOD_SERVICE;
  InputMethodManager m = (InputMethodManager)activity.getSystemService(s);
  View w = activity.getWindow().getDecorView();
  m.showSoftInput(w, 0);
}

This works fine for bringing up the keyboard, and works fine on some devices all together. But on other devices (e.g. Nexus 7), when the user tries to close the keyboard by hitting the "hide keyboard" button the application freezes with this debug output:

I/InputDispatcher(  453): Application is not responding: AppWindowToken{429b54a8 token=Token{42661288 ActivityRecord{41bb0b00 u0 com.example.project/android.app.NativeActivity}}} - Window{420d6138 u0 com.example.project/android.app.NativeActivity}.  It has been 5006.7ms since event, 5005.6ms since wait started.  Reason: Waiting because the focused window has not finished processing the input events that were previously delivered to it.
I/WindowManager(  453): Input event dispatching timed out sending to com.example.project/android.app.NativeActivity

And then the user is presented with a dialog box saying:

Project isn't responding. Do you want to close it? [Wait]/[OK]

Is there something we are doing obviously wrong? Or might this be a bug? Issues like this one seem to suggest keyboard functionality has never been properly implemented in the native glue.

On a side note, we havent tested on many devices yet, but the ones where it doesn't crash are ones with an older android OS. Also, on those where it does crash, when the keyboard appears, it changes the back button from one that looks like this to one that looks like this . Perhaps that corresponds to a different input event that wasn't accounted for when they first developed the native glue? I'm just guessing .

Anyway, if someone got soft keyboard working while using native activity, please let us know how you've done it.

Cheers

UPDATE

It has been reported as a bug in Android here, we would still be happy to hear about workarounds though. If you are also affected by it, you might want to cast a vote on that issue (by pressing the star).

Answer 1

Peter's solution works well. However if you don't want to modify the native_app_glue file: notice that process_input is assigned as a function pointer. In your implementation file, create your own process_input functions as described by Peter:

static void process_input( struct android_app* app, struct android_poll_source* source) {
    AInputEvent* event = NULL;
    if (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
        int type = AInputEvent_getType(event);
        LOGV("New input event: type=%d\n", AInputEvent_getType(event));

        bool skip_predispatch
              =  AInputEvent_getType(event)  == AINPUT_EVENT_TYPE_KEY
              && AKeyEvent_getKeyCode(event) == AKEYCODE_BACK;

        // skip predispatch (all it does is send to the IME)
        if (!skip_predispatch && AInputQueue_preDispatchEvent(app->inputQueue, event)) {
            return;
        }

        int32_t handled = 0;
        if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
        AInputQueue_finishEvent(app->inputQueue, event, handled);
    } else {
        LOGE("Failure reading next input event: %s\n", strerror(errno));
    }
}

At the beginning of your android_main function, assign your version of process_input to android_app->inputPollSource.process.

In your event handler make sure you check for the back key (AKEYCODE_BACK) and intercept it to hide your keyboard if visible.

Note that this problem appears to exist in Android 4.1 and 4.2 - solved in 4.3

Answer 2

OK, as mentioned in the UPDATE of my original question, this is a bug somewhere inside the Android OS. We've found a workaround, it is really ugly but it works so someone might find it useful.

First you'll need to modify the file

<NDK>/sources/android/native_app_glue/android_native_app_glue.c

by changing the function process_input to look like this:

// When user closes the software keyboard, this function is normally not
// called at all. On the buggy devices, it is called as if AKEYCODE_BACK
// was pressed. This event then gets consumed by the
// AInputQueue_preDispatchEvent. There should be some mechanism that then
// calls the process_input again to finish processing the input.
// But it never does and AInputQueue_finishEvent is never called, the OS
// notices this and closes our app.
static void process_input( struct android_app* app
                         , struct android_poll_source* source) {
    AInputEvent* event = NULL;
    if (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
        int type = AInputEvent_getType(event);
        LOGV("New input event: type=%d\n", AInputEvent_getType(event));

        int skip_predispatch
              =  AInputEvent_getType(event)  == AINPUT_EVENT_TYPE_KEY
              && AKeyEvent_getKeyCode(event) == AKEYCODE_BACK;

        // TODO: Not sure if we should skip the predispatch all together
        //       or run it but not return afterwards. The main thing
        //       is that the code below this 'if' block will be called.
        if (!skip_predispatch) {
          if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
              return;
          }
        }

        int32_t handled = 0;
        if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
        AInputQueue_finishEvent(app->inputQueue, event, handled);
    } else {
        LOGE("Failure reading next input event: %s\n", strerror(errno));
    }
}

Then you should have a code that looks something like this inside your own input event handler:

static int32_t handle_input(android_app* app, AInputEvent* event) {
  int32_t handled = 0;

  struct engine* engine = (struct engine*) app->userData;
  switch (AInputEvent_getType(event)) {
    case AINPUT_EVENT_TYPE_KEY:
      switch (AKeyEvent_getAction(event)) {
        case AKEY_EVENT_ACTION_DOWN:
          int key = AKeyEvent_getKeyCode(event);
          if (os_version_major == 4 && os_version_minor == 2) {
            if (m_keyboard_is_visible && key == AKEYCODE_BACK) {
              // You should set this to true when showing the keyboard.
              m_keyboard_is_visible = false;
              hide_keyboard();
              handled = 1;
              break;
            }
          }
          ... // your own "key down" event handling code.
          break;
      }
      break;
    ...
  }
  return handled;  
}

To get the OS version numbers we use another JNI calls to get it from android.os.Build.VERSION.RELEASE android.os.Build.VERSION.SDK_INT. To implement the show_keyboard and hide_keyboard use information from Ratamovics answer in this post.

NOTE To have the android_native_app_glue.c compiled automatically and to avoid doing changes directly to the NDK tree, you might want to copy the file to the jni/ directory of your project and ditch these two lines from your Android.mk

LOCAL_STATIC_LIBRARIES := android_native_app_glue
$(call import-module,android/native_app_glue)