Wyłapywanie WYJĄTKÓW wyrzucanych z kodu natywnego działającego na Androidzie

EDIT: Zobacz także ta bardziej elegancka odpowiedź.

Poniższy mechanizm oparty jest na makrze preprocesora C, które z powodzeniem zaimplementowałem w warstwie JNI.

Powyższe makro CATCH_CPP_EXCEPTION_AND_THROW_JAVA_EXCEPTION konwertuje wyjątki C++ na wyjątki Javy.

Zastąp mypackage::Exception przez własny wyjątek C++. Jeśli nie zdefiniowano odpowiedniej my.group.mypackage.Exception w Javie, zastąp "my/group/mypackage/Exception" przez "java/lang/RuntimeException".

#define CATCH_CPP_EXCEPTION_AND_THROW_JAVA_EXCEPTION              \
                                                                  \
  catch (const mypackage::Exception& e)                           \
  {                                                               \
    jclass jc = env->FindClass("my/group/mypackage/Exception");   \
    if(jc) env->ThrowNew (jc, e.what());                          \
    /* if null => NoClassDefFoundError already thrown */          \
  }                                                               \
  catch (const std::bad_alloc& e)                                 \
  {                                                               \
    /* OOM exception */                                           \
    jclass jc = env->FindClass("java/lang/OutOfMemoryError");     \
    if(jc) env->ThrowNew (jc, e.what());                          \
  }                                                               \
  catch (const std::ios_base::failure& e)                         \
  {                                                               \
    /* IO exception */                                            \
    jclass jc = env->FindClass("java/io/IOException");            \
    if(jc) env->ThrowNew (jc, e.what());                          \
  }                                                               \
  catch (const std::exception& e)                                 \
  {                                                               \
    /* unknown exception */                                       \
    jclass jc = env->FindClass("java/lang/Error");                \
    if(jc) env->ThrowNew (jc, e.what());                          \
  }                                                               \
  catch (...)                                                     \
  {                                                               \
    /* Oops I missed identifying this exception! */               \
    jclass jc = env->FindClass("java/lang/Error");                \
    if(jc) env->ThrowNew (jc, "unidentified exception");          \
  }

Plik Java_my_group_mypackage_example.cpp za pomocą powyższe makro:

JNIEXPORT jlong JNICALL Java_my_group_mypackage_example_function1
  (JNIEnv *env, jobject object, jlong value)
{
  try 
  {
    /* ... my processing ... */
    return jlong(result);
  }
  CATCH_CPP_EXCEPTION_AND_THROW_JAVA_EXCEPTION
  return 0;
}

JNIEXPORT jstring JNICALL Java_my_group_mypackage_example_function2
  (JNIEnv *env, jobject object, jlong value)
{
  try 
  {
    /* ... my processing ... */
    jstring jstr = env->NewStringUTF("my result");
    return  jstr;
  }
  CATCH_CPP_EXCEPTION_AND_THROW_JAVA_EXCEPTION
  return 0;
}

JNIEXPORT void JNICALL Java_my_group_mypackage_example_function3
  (JNIEnv *env, jobject object, jlong value)
{
  try 
  {
    /* ... my processing ... */
  }
  CATCH_CPP_EXCEPTION_AND_THROW_JAVA_EXCEPTION
}

Dla informacji lub ciekawości podaję poniżej odpowiedni kod Javy (plik example.java). Zauważ, że" my-DLL-name " jest powyższym kodem C / C++ skompilowanym jako DLL ("my-DLL-name "bez rozszerzenia" .dll"). Działa to również doskonale przy użyciu biblioteki współdzielonej Linux / Unix *.so.

package my.group.mypackage;

public class Example {
  static {
    System.loadLibrary("my-DLL-name");
  }

  public Example() {
    /* ... */
  }

  private native int    function1(int); //declare DLL functions
  private native String function2(int); //using the keyword
  private native void   function3(int); //'native'

  public void dosomething(int value) {
    int result = function1(value);  
    String str = function2(value);  //call your DLL functions
    function3(value);               //as any other java function
  }
}

Najpierw Wygeneruj example.class z example.java (używając javaclub swojego ulubionego IDE lub Mavena...). Po drugie, Wygeneruj plik nagłówkowy C / C++ Java_my_group_mypackage_example.h z example.class za pomocą javah.

Czy rozważałeś przechwycenie tego wyjątku, a następnie owinięcie go w wyjątek runtime, tylko po to, aby podnieść go wyżej w stosie?

Użyłem podobnego "hacka" w SCJD. Ogólnie NPE wskazuje na błąd z twojej strony, ale jeśli jesteś przekonany, że nie robisz nic złego, po prostu zrób dobrze udokumentowaną RuntimeException, która wyjaśnia, że wyjątek jest używany do bańki wyjątku. Następnie rozpakuj go i przetestuj, czy na przykład NPE i potraktuj go jako swój własny wyjątek.

Jeśli jest zamierzając spowodować błędne dane, nie masz innej opcji, ale dostać się do źródła.