En JNI, se puede pasar un parámetro C entero a un int primitivo de Java?

zfgo:

Tengo un método Java que deseen ser llamado desde algún método nativo:

    public void onDownloadProgress(int current, int total) {

    }

y yo estoy tratando de llamar al método anterior de Java a partir de un método nativo:

    int current = ...
    int total = ...
    jni_callVoidMethod(
        env,
        jDownloadCallback,
        "onDownloadProgress",
        "(II)V",
        current,
        total
    );

jni_callVoidMethod es un método de ayuda y su aplicación es:

    void jni_callVoidMethod(JNIEnv *env, jobject receiver, const char *methodName, const char *contract, ...) {
        jclass clazz = env->GetObjectClass(receiver);
            if (NULL != clazz) {
            jmethodID method = env->GetMethodID(
            clazz,
            methodName,
            contract
        );
        if (NULL != method) {
            BUILD_VARARGS()
                env->CallVoidMethodV(
                receiver,
                method,
                va_args
            );
        if (env->ExceptionCheck()) { // prints out the exception if one is present
            env->ExceptionDescribe();
            env->ExceptionClear();
        }
        va_end(va_args);
        }
        env->DeleteLocalRef(clazz);
    }
}

Sin embargo, en el método de Java que estoy recibiendo algunos valores int muy extrañas. Por ejemplo, 3840120912. Me pregunto se puede enviar directamente un int C a un int primitivo de Java en lugar de declarar los parámetros en el método Java para convertirse tipo entero? La declaración de estos dos parámetros como obras enteros para mí y estoy consiguiendo el valor correcto.

Editar: Aplicación de la BUILD_VARARGS macro:

#define BUILD_VARARGS() \
va_list va_args; \
va_start(va_args, contract); \
const char *cur = contract; \
while ('\0' != *cur && '(' != *cur) { /* skip to opening paren */ \
    cur++; \
} \
while ('\0' != *cur && ')' != *cur) { /* stop at closing paren */ \
    switch (*cur) { \
        case 'Z': \
            va_arg(va_args, int); /* bool (unsigned 8-bit int) */ \
            break; \
        case 'B': \
            va_arg(va_args, int); /* byte (signed 8-bit int) */ \
            break; \
        case 'C': \
            va_arg(va_args, int); /* char (unsigned 16-bit int) */ \
            break; \
        case 'S': \
            va_arg(va_args, int); /* short (signed 16-bit int) */ \
            break; \
        case 'I': \
            va_arg(va_args, long long); /* int (signed 32-bit int) (must be passed in as a long long) */ \
            break; \
        case 'J': \
            va_arg(va_args, long); /* long (signed 64-bit int) */ \
            break; \
        case 'F': \
            va_arg(va_args, double); /* float (32 bits) */ \
            break; \
        case 'D': \
            va_arg(va_args, double); /* double (64 bits) */ \
            break; \
        case 'L': \
            /* fully-qualified-class */ \
            while (';' != *++cur && '\0' != *cur); /* advance to end of class declaration */ \
            /* FIXME breaks varargs, seems to not be needed va_arg(va_args, jobject); */ \
            break; \
        case '[': \
            /* TODO type type[] */ \
        case '(': \
            /* TODO ( arg-types ) ret-type  method type */ \
        default: \
            break; \
    } \
    cur++; \
}

platija:

¡Eso lo explica todo! Sus llamadas a va_argconsumir los argumentos y cuando CallVoidMethodVllega a ella, que es la lectura de algún otro lugar en la pila. Desde el va_argManual:

El va_arg () se expande macro para una expresión que tiene el tipo y el valor del siguiente argumento en la llamada. El ap parámetro es el ap va_list inicializado por va_start ().
Cada llamada a va_arg (AP) modifica de manera que la siguiente llamada devuelve el siguiente argumento.

En su lugar, se debe crear el va_liste inmediatamente entregarlo fuera a CallVoidMethodV:

va_list va_args;
va_start(va_args, contract);
env->CallVoidMethodV(receiver, method, va_args);
va_end(va_args);