|
|
@ -1,8 +1,11 @@ |
|
|
#include <cassert> |
|
|
#include <cassert> |
|
|
#include "jniutils.hh" |
|
|
#include "jniutils.hh" |
|
|
#include <pEp/pEpLog.hh> |
|
|
#include <pEp/pEpLog.hh> |
|
|
|
|
|
|
|
|
#ifndef __LP64__ |
|
|
#ifndef __LP64__ |
|
|
|
|
|
|
|
|
#include <time64.h> |
|
|
#include <time64.h> |
|
|
|
|
|
|
|
|
#define time_t time64_t |
|
|
#define time_t time64_t |
|
|
#define timegm timegm64 |
|
|
#define timegm timegm64 |
|
|
#define gmtime_r gmtime64_r |
|
|
#define gmtime_r gmtime64_r |
|
|
@ -11,15 +14,14 @@ |
|
|
#endif |
|
|
#endif |
|
|
|
|
|
|
|
|
namespace pEp { |
|
|
namespace pEp { |
|
|
namespace JNIAdapter { |
|
|
namespace JNIAdapter { |
|
|
std::mutex global_mutex; |
|
|
|
|
|
std::unordered_map<long, std::mutex*> engine_objid_mutex; |
|
|
std::mutex global_mutex; |
|
|
|
|
|
std::unordered_map<long, std::mutex *> engine_objid_mutex; |
|
|
std::mutex* get_engine_java_object_mutex( |
|
|
|
|
|
JNIEnv *env, |
|
|
std::mutex *get_engine_java_object_mutex(JNIEnv *env, |
|
|
jobject obj |
|
|
jobject obj) |
|
|
) |
|
|
{ |
|
|
{ |
|
|
|
|
|
long engine_obj_id = static_cast<long>(callLongMethod(env, obj, "getId")); |
|
|
long engine_obj_id = static_cast<long>(callLongMethod(env, obj, "getId")); |
|
|
assert(engine_obj_id); |
|
|
assert(engine_obj_id); |
|
|
pEpLog("for java object id: " << engine_obj_id); |
|
|
pEpLog("for java object id: " << engine_obj_id); |
|
|
@ -27,30 +29,26 @@ namespace pEp { |
|
|
pEpLog("found mutex: " << engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle()); |
|
|
pEpLog("found mutex: " << engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle()); |
|
|
assert(engine_obj_mutex); |
|
|
assert(engine_obj_mutex); |
|
|
return engine_obj_mutex; |
|
|
return engine_obj_mutex; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void create_engine_java_object_mutex( |
|
|
void create_engine_java_object_mutex(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
jobject obj) |
|
|
jobject obj |
|
|
{ |
|
|
) |
|
|
|
|
|
{ |
|
|
|
|
|
long engine_obj_id = static_cast<long>(callLongMethod(env, obj, "getId")); |
|
|
long engine_obj_id = static_cast<long>(callLongMethod(env, obj, "getId")); |
|
|
assert(engine_obj_id); |
|
|
assert(engine_obj_id); |
|
|
std::mutex *engine_obj_mutex = new std::mutex(); |
|
|
std::mutex *engine_obj_mutex = new std::mutex(); |
|
|
pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object id: " << engine_obj_id); |
|
|
pEpLog(engine_obj_mutex << " with native_handle: " << engine_obj_mutex->native_handle() << " for java object id: " << engine_obj_id); |
|
|
assert(engine_obj_mutex); |
|
|
assert(engine_obj_mutex); |
|
|
if(engine_objid_mutex.count(engine_obj_id) > 0) { |
|
|
if (engine_objid_mutex.count(engine_obj_id) > 0) { |
|
|
pEpLog("Fatal: mutex already existing for object id: " << engine_obj_id); |
|
|
pEpLog("Fatal: mutex already existing for object id: " << engine_obj_id); |
|
|
assert(0); |
|
|
assert(0); |
|
|
} |
|
|
} |
|
|
engine_objid_mutex.insert(std::make_pair(engine_obj_id, engine_obj_mutex )); |
|
|
engine_objid_mutex.insert(std::make_pair(engine_obj_id, engine_obj_mutex)); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void release_engine_java_object_mutex( |
|
|
void release_engine_java_object_mutex(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
jobject obj) |
|
|
jobject obj |
|
|
{ |
|
|
) |
|
|
|
|
|
{ |
|
|
|
|
|
long engine_obj_id = static_cast<long>(callLongMethod(env, obj, "getId")); |
|
|
long engine_obj_id = static_cast<long>(callLongMethod(env, obj, "getId")); |
|
|
assert(engine_obj_id); |
|
|
assert(engine_obj_id); |
|
|
std::mutex *engine_obj_mutex = engine_objid_mutex.at(engine_obj_id); |
|
|
std::mutex *engine_obj_mutex = engine_objid_mutex.at(engine_obj_id); |
|
|
@ -58,13 +56,15 @@ namespace pEp { |
|
|
assert(engine_obj_mutex); |
|
|
assert(engine_obj_mutex); |
|
|
engine_objid_mutex.erase(engine_obj_id); |
|
|
engine_objid_mutex.erase(engine_obj_id); |
|
|
delete engine_obj_mutex; |
|
|
delete engine_obj_mutex; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jclass findClass(JNIEnv *env, const char *classname) |
|
|
jclass findClass(JNIEnv *env, |
|
|
{ |
|
|
const char *classname) |
|
|
|
|
|
{ |
|
|
jclass clazz = env->FindClass(classname); |
|
|
jclass clazz = env->FindClass(classname); |
|
|
if (!clazz) |
|
|
if (!clazz) { |
|
|
fprintf(stderr, "class not found: %s\n", classname); |
|
|
fprintf(stderr, "class not found: %s\n", classname); |
|
|
|
|
|
} |
|
|
assert(clazz); |
|
|
assert(clazz); |
|
|
|
|
|
|
|
|
if (clazz == NULL) { |
|
|
if (clazz == NULL) { |
|
|
@ -75,15 +75,13 @@ namespace pEp { |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return clazz; |
|
|
return clazz; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jfieldID getFieldID( |
|
|
jfieldID getFieldID(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
|
|
|
const char *classname, |
|
|
const char *classname, |
|
|
const char *fieldname, |
|
|
const char *fieldname, |
|
|
const char *signature |
|
|
const char *signature) |
|
|
) |
|
|
{ |
|
|
{ |
|
|
|
|
|
jclass clazz = findClass(env, classname); |
|
|
jclass clazz = findClass(env, classname); |
|
|
assert(clazz); |
|
|
assert(clazz); |
|
|
|
|
|
|
|
|
@ -100,18 +98,15 @@ namespace pEp { |
|
|
env->DeleteLocalRef(clazz); |
|
|
env->DeleteLocalRef(clazz); |
|
|
|
|
|
|
|
|
return field; |
|
|
return field; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
//TODO: fix/generalize/clean patch added to make keysync work using globalref to class
|
|
|
//TODO: fix/generalize/clean patch added to make keysync work using globalref to class
|
|
|
jfieldID getFieldID( |
|
|
jfieldID getFieldID(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
|
|
|
const char *classname, |
|
|
const char *classname, |
|
|
const char *fieldname, |
|
|
const char *fieldname, |
|
|
const char *signature, |
|
|
const char *signature, |
|
|
const jclass clazz |
|
|
const jclass clazz) |
|
|
) |
|
|
{ |
|
|
{ |
|
|
|
|
|
|
|
|
|
|
|
jfieldID field = env->GetFieldID(clazz, fieldname, signature); |
|
|
jfieldID field = env->GetFieldID(clazz, fieldname, signature); |
|
|
assert(field); |
|
|
assert(field); |
|
|
|
|
|
|
|
|
@ -124,14 +119,12 @@ namespace pEp { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return field; |
|
|
return field; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jint callIntMethod( |
|
|
jint callIntMethod(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
|
|
|
jobject obj, |
|
|
jobject obj, |
|
|
const char *methodname |
|
|
const char *methodname) |
|
|
) |
|
|
{ |
|
|
{ |
|
|
|
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
assert(clazz); |
|
|
assert(clazz); |
|
|
|
|
|
|
|
|
@ -148,14 +141,12 @@ namespace pEp { |
|
|
jint result = env->CallIntMethod(obj, method); |
|
|
jint result = env->CallIntMethod(obj, method); |
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
return result; |
|
|
return result; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jlong callLongMethod( |
|
|
jlong callLongMethod(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
|
|
|
jobject obj, |
|
|
jobject obj, |
|
|
const char *methodname |
|
|
const char *methodname) |
|
|
) |
|
|
{ |
|
|
{ |
|
|
|
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
assert(clazz); |
|
|
assert(clazz); |
|
|
|
|
|
|
|
|
@ -172,20 +163,17 @@ namespace pEp { |
|
|
jlong result = env->CallLongMethod(obj, method); |
|
|
jlong result = env->CallLongMethod(obj, method); |
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
return result; |
|
|
return result; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject callObjectMethod( |
|
|
jobject callObjectMethod(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
|
|
|
jobject obj, |
|
|
jobject obj, |
|
|
const char *methodname, |
|
|
const char *methodname, |
|
|
jint index |
|
|
jint index) |
|
|
) |
|
|
{ |
|
|
{ |
|
|
|
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
assert(clazz); |
|
|
assert(clazz); |
|
|
|
|
|
|
|
|
jmethodID method = env->GetMethodID(clazz, methodname, |
|
|
jmethodID method = env->GetMethodID(clazz, methodname, "(I)Ljava/lang/Object;"); |
|
|
"(I)Ljava/lang/Object;"); |
|
|
|
|
|
if (method == NULL) { |
|
|
if (method == NULL) { |
|
|
jclass ex = env->FindClass("java/lang/NoSuchMethodError"); |
|
|
jclass ex = env->FindClass("java/lang/NoSuchMethodError"); |
|
|
assert(ex); |
|
|
assert(ex); |
|
|
@ -198,20 +186,17 @@ namespace pEp { |
|
|
jobject result = env->CallObjectMethod(obj, method, index); |
|
|
jobject result = env->CallObjectMethod(obj, method, index); |
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
return result; |
|
|
return result; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jboolean callBooleanMethod( |
|
|
jboolean callBooleanMethod(JNIEnv *env, |
|
|
JNIEnv *env, |
|
|
|
|
|
jobject obj, |
|
|
jobject obj, |
|
|
const char *methodname, |
|
|
const char *methodname, |
|
|
jobject o |
|
|
jobject o) |
|
|
) |
|
|
{ |
|
|
{ |
|
|
|
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
jclass clazz = env->GetObjectClass(obj); |
|
|
assert(clazz); |
|
|
assert(clazz); |
|
|
|
|
|
|
|
|
jmethodID method = env->GetMethodID(clazz, methodname, |
|
|
jmethodID method = env->GetMethodID(clazz, methodname, "(Ljava/lang/Object;)Z"); |
|
|
"(Ljava/lang/Object;)Z"); |
|
|
|
|
|
if (method == NULL) { |
|
|
if (method == NULL) { |
|
|
jclass ex = env->FindClass("java/lang/NoSuchMethodError"); |
|
|
jclass ex = env->FindClass("java/lang/NoSuchMethodError"); |
|
|
assert(ex); |
|
|
assert(ex); |
|
|
@ -224,20 +209,21 @@ namespace pEp { |
|
|
jboolean result = env->CallBooleanMethod(obj, method, o); |
|
|
jboolean result = env->CallBooleanMethod(obj, method, o); |
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
env->ExceptionCheck(); // handle exception in Java
|
|
|
return result; |
|
|
return result; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jint outOfMemory(JNIEnv *env) |
|
|
jint outOfMemory(JNIEnv *env) |
|
|
{ |
|
|
{ |
|
|
jclass ex; |
|
|
jclass ex; |
|
|
const char *ex_name = "java/lang/OutOfMemoryError"; |
|
|
const char *ex_name = "java/lang/OutOfMemoryError"; |
|
|
|
|
|
|
|
|
ex = env->FindClass(ex_name); |
|
|
ex = env->FindClass(ex_name); |
|
|
assert(ex); |
|
|
assert(ex); |
|
|
return env->ThrowNew(ex, ex_name); |
|
|
return env->ThrowNew(ex, ex_name); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject from_Integer(JNIEnv *env, int val) |
|
|
jobject from_Integer(JNIEnv *env, |
|
|
{ |
|
|
int val) |
|
|
|
|
|
{ |
|
|
assert(env); |
|
|
assert(env); |
|
|
jclass clazz = findClass(env, "java/lang/Integer"); |
|
|
jclass clazz = findClass(env, "java/lang/Integer"); |
|
|
|
|
|
|
|
|
@ -247,47 +233,52 @@ namespace pEp { |
|
|
jobject obj = env->NewObject(clazz, constructor, val); |
|
|
jobject obj = env->NewObject(clazz, constructor, val); |
|
|
assert(obj); |
|
|
assert(obj); |
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
int to_Integer(JNIEnv *env, jobject obj) |
|
|
int to_Integer(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
|
|
|
{ |
|
|
assert(env && obj); |
|
|
assert(env && obj); |
|
|
int _val = callIntMethod(env, obj, "intValue"); |
|
|
int _val = callIntMethod(env, obj, "intValue"); |
|
|
return _val; |
|
|
return _val; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jbyteArray from_string(JNIEnv *env, const char *str) |
|
|
jbyteArray from_string(JNIEnv *env, |
|
|
{ |
|
|
const char *str) |
|
|
|
|
|
{ |
|
|
if (str && str[0]) { |
|
|
if (str && str[0]) { |
|
|
jboolean isCopy; |
|
|
jboolean isCopy; |
|
|
size_t l = strlen(str); |
|
|
size_t l = strlen(str); |
|
|
jbyteArray _str = env->NewByteArray(l); |
|
|
jbyteArray _str = env->NewByteArray(l); |
|
|
env->SetByteArrayRegion(_str, 0, l, (jbyte*)str); |
|
|
env->SetByteArrayRegion(_str, 0, l, (jbyte *) str); |
|
|
return _str; |
|
|
return _str; |
|
|
} |
|
|
} else if (str) { |
|
|
else if (str) { |
|
|
|
|
|
return env->NewByteArray(0); |
|
|
return env->NewByteArray(0); |
|
|
} else { |
|
|
} else { |
|
|
return (jbyteArray) NULL; |
|
|
return (jbyteArray) NULL; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
char *to_string(JNIEnv *env, jbyteArray str) |
|
|
char *to_string(JNIEnv *env, |
|
|
{ |
|
|
jbyteArray str) |
|
|
if (str == NULL) |
|
|
{ |
|
|
|
|
|
if (str == NULL) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
size_t l = env->GetArrayLength(str); |
|
|
size_t l = env->GetArrayLength(str); |
|
|
char *_str = static_cast<char*>(calloc(1,l+1)); |
|
|
char *_str = static_cast<char *>(calloc(1, l + 1)); |
|
|
assert(_str); |
|
|
assert(_str); |
|
|
env->GetByteArrayRegion(str, 0, l, (jbyte*)_str); |
|
|
env->GetByteArrayRegion(str, 0, l, (jbyte *) _str); |
|
|
return _str; |
|
|
return _str; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject from_stringlist(JNIEnv *env, stringlist_t *sl) |
|
|
jobject from_stringlist(JNIEnv *env, |
|
|
{ |
|
|
stringlist_t *sl) |
|
|
if (!sl) |
|
|
{ |
|
|
|
|
|
if (!sl) { |
|
|
return (jobject) NULL; |
|
|
return (jobject) NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jclass clazz = findClass(env, "java/util/Vector"); |
|
|
jclass clazz = findClass(env, "java/util/Vector"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
@ -304,16 +295,19 @@ namespace pEp { |
|
|
env->DeleteLocalRef(clazz); |
|
|
env->DeleteLocalRef(clazz); |
|
|
|
|
|
|
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
stringlist_t *to_stringlist(JNIEnv *env, jobject obj) |
|
|
stringlist_t *to_stringlist(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
if (!obj) |
|
|
{ |
|
|
|
|
|
if (!obj) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
if (size == 0) |
|
|
if (size == 0) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
stringlist_t *sl = new_stringlist(NULL); |
|
|
stringlist_t *sl = new_stringlist(NULL); |
|
|
stringlist_t *_sl; |
|
|
stringlist_t *_sl; |
|
|
@ -321,26 +315,27 @@ namespace pEp { |
|
|
for (_sl = sl, i = 0; i < (int) size; i++) { |
|
|
for (_sl = sl, i = 0; i < (int) size; i++) { |
|
|
jobject o = callObjectMethod(env, obj, "get", i); |
|
|
jobject o = callObjectMethod(env, obj, "get", i); |
|
|
jbyteArray a = static_cast<jbyteArray>(o); |
|
|
jbyteArray a = static_cast<jbyteArray>(o); |
|
|
char * str = to_string(env, a); |
|
|
char *str = to_string(env, a); |
|
|
_sl = stringlist_add(_sl, str); |
|
|
_sl = stringlist_add(_sl, str); |
|
|
env->DeleteLocalRef(o); |
|
|
env->DeleteLocalRef(o); |
|
|
free(str); |
|
|
free(str); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return sl; |
|
|
return sl; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject from_stringpairlist(JNIEnv *env, stringpair_list_t *sl) |
|
|
jobject from_stringpairlist(JNIEnv *env, |
|
|
{ |
|
|
stringpair_list_t *sl) |
|
|
if (!sl) |
|
|
{ |
|
|
|
|
|
if (!sl) { |
|
|
return (jobject) NULL; |
|
|
return (jobject) NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jclass clazz = findClass(env, "java/util/ArrayList"); |
|
|
jclass clazz = findClass(env, "java/util/ArrayList"); |
|
|
jclass clazz_pair = findClass(env, "foundation/pEp/jniadapter/Pair"); |
|
|
jclass clazz_pair = findClass(env, "foundation/pEp/jniadapter/Pair"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
assert(constructor); |
|
|
assert(constructor); |
|
|
jmethodID constructor_pair = env->GetMethodID(clazz_pair, "<init>", |
|
|
jmethodID constructor_pair = env->GetMethodID(clazz_pair, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V"); |
|
|
"(Ljava/lang/Object;Ljava/lang/Object;)V"); |
|
|
|
|
|
assert(constructor_pair); |
|
|
assert(constructor_pair); |
|
|
|
|
|
|
|
|
jobject obj = env->NewObject(clazz, constructor); |
|
|
jobject obj = env->NewObject(clazz, constructor); |
|
|
@ -353,36 +348,34 @@ namespace pEp { |
|
|
|
|
|
|
|
|
jbyteArray first = from_string(env, _sl->value->key); |
|
|
jbyteArray first = from_string(env, _sl->value->key); |
|
|
jbyteArray second = from_string(env, _sl->value->value); |
|
|
jbyteArray second = from_string(env, _sl->value->value); |
|
|
jobject pair = env->NewObject(clazz_pair, constructor_pair, |
|
|
jobject pair = env->NewObject(clazz_pair, constructor_pair, first, second); |
|
|
first, second); |
|
|
|
|
|
callBooleanMethod(env, obj, "add", pair); |
|
|
callBooleanMethod(env, obj, "add", pair); |
|
|
|
|
|
|
|
|
env->DeleteLocalRef(first); |
|
|
env->DeleteLocalRef(first); |
|
|
env->DeleteLocalRef(second); |
|
|
env->DeleteLocalRef(second); |
|
|
env->DeleteLocalRef(pair); |
|
|
env->DeleteLocalRef(pair); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
env->DeleteLocalRef(clazz); |
|
|
env->DeleteLocalRef(clazz); |
|
|
env->DeleteLocalRef(clazz_pair); |
|
|
env->DeleteLocalRef(clazz_pair); |
|
|
|
|
|
|
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
stringpair_list_t *to_stringpairlist(JNIEnv *env, jobject obj) |
|
|
stringpair_list_t *to_stringpairlist(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
if (!obj) |
|
|
{ |
|
|
|
|
|
if (!obj) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
if (size == 0) |
|
|
if (size == 0) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jfieldID first_id = getFieldID(env, "foundation/pEp/jniadapter/Pair", |
|
|
jfieldID first_id = getFieldID(env, "foundation/pEp/jniadapter/Pair", "first", "Ljava/lang/Object;"); |
|
|
"first", "Ljava/lang/Object;"); |
|
|
jfieldID second_id = getFieldID(env, "foundation/pEp/jniadapter/Pair", "second", "Ljava/lang/Object;"); |
|
|
jfieldID second_id = getFieldID(env, "foundation/pEp/jniadapter/Pair", |
|
|
|
|
|
"second", "Ljava/lang/Object;"); |
|
|
|
|
|
|
|
|
|
|
|
stringpair_list_t *sl = new_stringpair_list(NULL); |
|
|
stringpair_list_t *sl = new_stringpair_list(NULL); |
|
|
stringpair_list_t *_sl; |
|
|
stringpair_list_t *_sl; |
|
|
@ -390,12 +383,8 @@ namespace pEp { |
|
|
|
|
|
|
|
|
for (_sl = sl, i = 0; i < (int) size; i++) { |
|
|
for (_sl = sl, i = 0; i < (int) size; i++) { |
|
|
jobject pair = callObjectMethod(env, obj, "get", i); |
|
|
jobject pair = callObjectMethod(env, obj, "get", i); |
|
|
jbyteArray first = |
|
|
jbyteArray first = static_cast<jbyteArray>(env->GetObjectField(pair, first_id)); |
|
|
static_cast<jbyteArray>(env->GetObjectField(pair, |
|
|
jbyteArray second = static_cast<jbyteArray>(env->GetObjectField(pair, second_id)); |
|
|
first_id)); |
|
|
|
|
|
jbyteArray second = |
|
|
|
|
|
static_cast<jbyteArray>(env->GetObjectField(pair, |
|
|
|
|
|
second_id)); |
|
|
|
|
|
|
|
|
|
|
|
char *first_str = to_string(env, first); |
|
|
char *first_str = to_string(env, first); |
|
|
char *second_str = to_string(env, second); |
|
|
char *second_str = to_string(env, second); |
|
|
@ -408,12 +397,14 @@ namespace pEp { |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return sl; |
|
|
return sl; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject from_timestamp(JNIEnv *env, timestamp *ts) |
|
|
jobject from_timestamp(JNIEnv *env, |
|
|
{ |
|
|
timestamp *ts) |
|
|
if (!ts) |
|
|
{ |
|
|
|
|
|
if (!ts) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
//LOGD("/* Seconds (0-60) */ FROM :%d", ts->tm_sec);
|
|
|
//LOGD("/* Seconds (0-60) */ FROM :%d", ts->tm_sec);
|
|
|
//LOGD("/* Minutes (0-59) */ :%d", ts->tm_min);
|
|
|
//LOGD("/* Minutes (0-59) */ :%d", ts->tm_min);
|
|
|
@ -422,7 +413,7 @@ namespace pEp { |
|
|
//LOGD("/* Month (0-11) */ :%d", ts->tm_mon);
|
|
|
//LOGD("/* Month (0-11) */ :%d", ts->tm_mon);
|
|
|
//LOGD("/* Year - 1900 */ :%d", ts->tm_year);
|
|
|
//LOGD("/* Year - 1900 */ :%d", ts->tm_year);
|
|
|
|
|
|
|
|
|
time_t t = timegm(ts)*1000; |
|
|
time_t t = timegm(ts) * 1000; |
|
|
//LOGD( "TimeGM returns : %lld", t);
|
|
|
//LOGD( "TimeGM returns : %lld", t);
|
|
|
jclass clazz = findClass(env, "java/util/Date"); |
|
|
jclass clazz = findClass(env, "java/util/Date"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(J)V"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(J)V"); |
|
|
@ -433,23 +424,25 @@ namespace pEp { |
|
|
env->DeleteLocalRef(clazz); |
|
|
env->DeleteLocalRef(clazz); |
|
|
|
|
|
|
|
|
return result; |
|
|
return result; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
} |
|
|
timestamp *to_timestamp(JNIEnv *env, |
|
|
|
|
|
jobject date) |
|
|
timestamp *to_timestamp(JNIEnv *env, jobject date) |
|
|
{ |
|
|
{ |
|
|
if (!date) { |
|
|
if (!date) |
|
|
|
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jlong t = callLongMethod(env, date, "getTime"); |
|
|
jlong t = callLongMethod(env, date, "getTime"); |
|
|
//LOGD( "Set Time to : %lld", t);
|
|
|
//LOGD( "Set Time to : %lld", t);
|
|
|
timestamp *ts = static_cast<timestamp*>(calloc(1, sizeof(timestamp))); |
|
|
timestamp *ts = static_cast<timestamp *>(calloc(1, sizeof(timestamp))); |
|
|
assert(ts); |
|
|
assert(ts); |
|
|
if (ts == NULL) |
|
|
if (ts == NULL) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
if (t){ |
|
|
if (t) { |
|
|
time_t clock = t/1000; |
|
|
time_t clock = t / 1000; |
|
|
gmtime_r(&clock, ts); |
|
|
gmtime_r(&clock, ts); |
|
|
|
|
|
|
|
|
//LOGD("/* Seconds (0-60) */ TO :%d", ts->tm_sec);
|
|
|
//LOGD("/* Seconds (0-60) */ TO :%d", ts->tm_sec);
|
|
|
@ -461,33 +454,40 @@ namespace pEp { |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return ts; |
|
|
return ts; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
static void _setStringField(JNIEnv *env, const char *classname, |
|
|
static void _setStringField(JNIEnv *env, |
|
|
jobject obj, const char *name, const char *value) |
|
|
const char *classname, |
|
|
{ |
|
|
jobject obj, |
|
|
|
|
|
const char *name, |
|
|
|
|
|
const char *value) |
|
|
|
|
|
{ |
|
|
if (value) { |
|
|
if (value) { |
|
|
jfieldID fieldID = getFieldID(env, classname, name, "[B"); |
|
|
jfieldID fieldID = getFieldID(env, classname, name, "[B"); |
|
|
env->SetObjectField(obj, fieldID, static_cast<jobject>(from_string(env, value))); |
|
|
env->SetObjectField(obj, fieldID, static_cast<jobject>(from_string(env, value))); |
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
//TODO: fix/generalize/clean patch added to make keysync work using globalref to class
|
|
|
//TODO: fix/generalize/clean patch added to make keysync work using globalref to class
|
|
|
static void _setStringField(JNIEnv *env, const char *classname, |
|
|
static void _setStringField(JNIEnv *env, |
|
|
jobject obj, const char *name, const char *value, const jclass clazz) |
|
|
const char *classname, |
|
|
{ |
|
|
jobject obj, |
|
|
|
|
|
const char *name, |
|
|
|
|
|
const char *value, |
|
|
|
|
|
const jclass clazz) |
|
|
|
|
|
{ |
|
|
if (value) { |
|
|
if (value) { |
|
|
jfieldID fieldID = getFieldID(env, classname, name, "[B", clazz); |
|
|
jfieldID fieldID = getFieldID(env, classname, name, "[B", clazz); |
|
|
env->SetObjectField(obj, fieldID, static_cast<jobject>(from_string(env, value))); |
|
|
env->SetObjectField(obj, fieldID, static_cast<jobject>(from_string(env, value))); |
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jobject from_identity(JNIEnv *env, pEp_identity *ident) |
|
|
jobject from_identity(JNIEnv *env, |
|
|
{ |
|
|
pEp_identity *ident) |
|
|
if (!ident) |
|
|
{ |
|
|
|
|
|
if (!ident) { |
|
|
return (jobject) NULL; |
|
|
return (jobject) NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
static const char *classname = "foundation/pEp/jniadapter/_Identity"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/_Identity"; |
|
|
jclass clazz = findClass(env, classname); |
|
|
jclass clazz = findClass(env, classname); |
|
|
@ -516,13 +516,16 @@ namespace pEp { |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
//TODO: fix/generalize/clean patch added to make keysync work using globalref to class
|
|
|
//TODO: fix/generalize/clean patch added to make keysync work using globalref to class
|
|
|
jobject from_identity(JNIEnv *env, pEp_identity *ident, jclass identityClass) |
|
|
jobject from_identity(JNIEnv *env, |
|
|
{ |
|
|
pEp_identity *ident, |
|
|
if (!ident) |
|
|
jclass identityClass) |
|
|
|
|
|
{ |
|
|
|
|
|
if (!ident) { |
|
|
return (jobject) NULL; |
|
|
return (jobject) NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
static const char *classname = "foundation/pEp/jniadapter/_Identity"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/_Identity"; |
|
|
jmethodID constructor = env->GetMethodID(identityClass, "<init>", "()V"); |
|
|
jmethodID constructor = env->GetMethodID(identityClass, "<init>", "()V"); |
|
|
@ -548,11 +551,13 @@ namespace pEp { |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
char *_getStringField(JNIEnv *env, const char *classname, jobject obj, |
|
|
char *_getStringField(JNIEnv *env, |
|
|
|
|
|
const char *classname, |
|
|
|
|
|
jobject obj, |
|
|
const char *name) |
|
|
const char *name) |
|
|
{ |
|
|
{ |
|
|
jfieldID fieldID = getFieldID(env, classname, name, "[B"); |
|
|
jfieldID fieldID = getFieldID(env, classname, name, "[B"); |
|
|
jobject fobj = env->GetObjectField(obj, fieldID); |
|
|
jobject fobj = env->GetObjectField(obj, fieldID); |
|
|
|
|
|
|
|
|
@ -560,12 +565,14 @@ namespace pEp { |
|
|
|
|
|
|
|
|
env->DeleteLocalRef(fobj); |
|
|
env->DeleteLocalRef(fobj); |
|
|
return res; |
|
|
return res; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
pEp_identity *to_identity(JNIEnv *env, jobject obj) |
|
|
pEp_identity *to_identity(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
if (!obj) |
|
|
{ |
|
|
|
|
|
if (!obj) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
static const char *classname = "foundation/pEp/jniadapter/_Identity"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/_Identity"; |
|
|
pEp_identity *ident = new_identity(NULL, NULL, NULL, NULL); |
|
|
pEp_identity *ident = new_identity(NULL, NULL, NULL, NULL); |
|
|
@ -592,12 +599,14 @@ namespace pEp { |
|
|
ident->flags = static_cast<identity_flags_t>(env->GetIntField(obj, flags_id)); |
|
|
ident->flags = static_cast<identity_flags_t>(env->GetIntField(obj, flags_id)); |
|
|
|
|
|
|
|
|
return ident; |
|
|
return ident; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject from_identitylist(JNIEnv *env, identity_list *il) |
|
|
jobject from_identitylist(JNIEnv *env, |
|
|
{ |
|
|
identity_list *il) |
|
|
if (!il) |
|
|
{ |
|
|
|
|
|
if (!il) { |
|
|
return (jobject) NULL; |
|
|
return (jobject) NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jclass clazz = findClass(env, "java/util/Vector"); |
|
|
jclass clazz = findClass(env, "java/util/Vector"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
@ -614,34 +623,39 @@ namespace pEp { |
|
|
env->DeleteLocalRef(clazz); |
|
|
env->DeleteLocalRef(clazz); |
|
|
|
|
|
|
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
identity_list *to_identitylist(JNIEnv *env, jobject obj) |
|
|
identity_list *to_identitylist(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
if (!obj) |
|
|
{ |
|
|
|
|
|
if (!obj) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
if (size == 0) |
|
|
if (size == 0) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
identity_list *il = new_identity_list(NULL); |
|
|
identity_list *il = new_identity_list(NULL); |
|
|
identity_list *_il; |
|
|
identity_list *_il; |
|
|
jint i; |
|
|
jint i; |
|
|
for (_il = il, i = 0; i < (int) size; i++) { |
|
|
for (_il = il, i = 0; i < (int) size; i++) { |
|
|
jobject o = callObjectMethod(env, obj, "get", i); |
|
|
jobject o = callObjectMethod(env, obj, "get", i); |
|
|
pEp_identity* ident = to_identity(env, o); |
|
|
pEp_identity *ident = to_identity(env, o); |
|
|
_il = identity_list_add(_il, ident); |
|
|
_il = identity_list_add(_il, ident); |
|
|
env->DeleteLocalRef(o); |
|
|
env->DeleteLocalRef(o); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return il; |
|
|
return il; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject _from_blob(JNIEnv *env, bloblist_t *b) |
|
|
jobject _from_blob(JNIEnv *env, |
|
|
{ |
|
|
bloblist_t *b) |
|
|
if (!b) |
|
|
{ |
|
|
|
|
|
if (!b) { |
|
|
return (jobject) NULL; |
|
|
return (jobject) NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
static const char *classname = "foundation/pEp/jniadapter/_Blob"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/_Blob"; |
|
|
jclass clazz = findClass(env, classname); |
|
|
jclass clazz = findClass(env, classname); |
|
|
@ -653,18 +667,20 @@ namespace pEp { |
|
|
|
|
|
|
|
|
jfieldID fieldID = getFieldID(env, classname, "data", "[B"); |
|
|
jfieldID fieldID = getFieldID(env, classname, "data", "[B"); |
|
|
jbyteArray _data = env->NewByteArray(static_cast<jsize>(b->size)); |
|
|
jbyteArray _data = env->NewByteArray(static_cast<jsize>(b->size)); |
|
|
env->SetByteArrayRegion(_data, 0, b->size, reinterpret_cast<jbyte*>(b->value)); |
|
|
env->SetByteArrayRegion(_data, 0, b->size, reinterpret_cast<jbyte *>(b->value)); |
|
|
env->SetObjectField(obj, fieldID, static_cast<jobject>(_data)); |
|
|
env->SetObjectField(obj, fieldID, static_cast<jobject>(_data)); |
|
|
_setStringField(env, classname, obj, "mime_type", b->mime_type); |
|
|
_setStringField(env, classname, obj, "mime_type", b->mime_type); |
|
|
_setStringField(env, classname, obj, "filename", b->filename); |
|
|
_setStringField(env, classname, obj, "filename", b->filename); |
|
|
|
|
|
|
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
jobject from_bloblist(JNIEnv *env, bloblist_t *bl) |
|
|
jobject from_bloblist(JNIEnv *env, |
|
|
{ |
|
|
bloblist_t *bl) |
|
|
if (!bl) |
|
|
{ |
|
|
|
|
|
if (!bl) { |
|
|
return (jobject) NULL; |
|
|
return (jobject) NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jclass clazz = findClass(env, "java/util/Vector"); |
|
|
jclass clazz = findClass(env, "java/util/Vector"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
jmethodID constructor = env->GetMethodID(clazz, "<init>", "()V"); |
|
|
@ -677,17 +693,20 @@ namespace pEp { |
|
|
bloblist_t *_bl; |
|
|
bloblist_t *_bl; |
|
|
for (_bl = bl; _bl && _bl->value; _bl = _bl->next) { |
|
|
for (_bl = bl; _bl && _bl->value; _bl = _bl->next) { |
|
|
jobject o = _from_blob(env, _bl); |
|
|
jobject o = _from_blob(env, _bl); |
|
|
if(o) |
|
|
if (o) { |
|
|
callBooleanMethod(env, obj, "add", o); |
|
|
callBooleanMethod(env, obj, "add", o); |
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
return obj; |
|
|
return obj; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
bloblist_t *to_blob(JNIEnv *env, jobject obj) |
|
|
bloblist_t *to_blob(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
if (!obj) |
|
|
{ |
|
|
|
|
|
if (!obj) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
static const char *classname = "foundation/pEp/jniadapter/_Blob"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/_Blob"; |
|
|
jclass clazz = findClass(env, classname); |
|
|
jclass clazz = findClass(env, classname); |
|
|
@ -701,23 +720,26 @@ namespace pEp { |
|
|
char *b = static_cast<char *>(malloc(size)); |
|
|
char *b = static_cast<char *>(malloc(size)); |
|
|
assert(b); |
|
|
assert(b); |
|
|
|
|
|
|
|
|
env->GetByteArrayRegion(_data, 0, size, reinterpret_cast<jbyte*>(b)); |
|
|
env->GetByteArrayRegion(_data, 0, size, reinterpret_cast<jbyte *>(b)); |
|
|
bloblist_t *bl = new_bloblist( b, size, mime_type, filename); |
|
|
bloblist_t *bl = new_bloblist(b, size, mime_type, filename); |
|
|
|
|
|
|
|
|
free(mime_type); |
|
|
free(mime_type); |
|
|
free(filename); |
|
|
free(filename); |
|
|
return bl; |
|
|
return bl; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bloblist_t *to_bloblist(JNIEnv *env, jobject obj) |
|
|
bloblist_t *to_bloblist(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
if (!obj) |
|
|
{ |
|
|
|
|
|
if (!obj) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
jint size = callIntMethod(env, obj, "size"); |
|
|
if (size == 0) |
|
|
if (size == 0) { |
|
|
return NULL; |
|
|
return NULL; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL); |
|
|
bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL); |
|
|
bloblist_t *_bl; |
|
|
bloblist_t *_bl; |
|
|
@ -731,10 +753,11 @@ namespace pEp { |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return bl; |
|
|
return bl; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
PEP_enc_format to_EncFormat(JNIEnv *env, jobject obj) |
|
|
PEP_enc_format to_EncFormat(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
|
|
|
{ |
|
|
static const char *classname = "foundation/pEp/jniadapter/Message$EncFormat"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/Message$EncFormat"; |
|
|
jclass clazz_enc_format = findClass(env, classname); |
|
|
jclass clazz_enc_format = findClass(env, classname); |
|
|
jfieldID field_value = env->GetFieldID(clazz_enc_format, "value", "I"); |
|
|
jfieldID field_value = env->GetFieldID(clazz_enc_format, "value", "I"); |
|
|
@ -742,10 +765,11 @@ namespace pEp { |
|
|
|
|
|
|
|
|
env->DeleteLocalRef(clazz_enc_format); |
|
|
env->DeleteLocalRef(clazz_enc_format); |
|
|
return static_cast<PEP_enc_format>(env->GetIntField(obj, field_value)); |
|
|
return static_cast<PEP_enc_format>(env->GetIntField(obj, field_value)); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
PEP_CIPHER_SUITE to_CipherSuite(JNIEnv *env, jobject obj) |
|
|
PEP_CIPHER_SUITE to_CipherSuite(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
|
|
|
{ |
|
|
static const char *classname = "foundation/pEp/jniadapter/CipherSuite"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/CipherSuite"; |
|
|
jclass clazz_enc_format = findClass(env, classname); |
|
|
jclass clazz_enc_format = findClass(env, classname); |
|
|
jfieldID field_value = env->GetFieldID(clazz_enc_format, "value", "I"); |
|
|
jfieldID field_value = env->GetFieldID(clazz_enc_format, "value", "I"); |
|
|
@ -753,10 +777,11 @@ namespace pEp { |
|
|
|
|
|
|
|
|
env->DeleteLocalRef(clazz_enc_format); |
|
|
env->DeleteLocalRef(clazz_enc_format); |
|
|
return static_cast<PEP_CIPHER_SUITE>(env->GetIntField(obj, field_value)); |
|
|
return static_cast<PEP_CIPHER_SUITE>(env->GetIntField(obj, field_value)); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
sync_handshake_result to_SyncHandshakeResult(JNIEnv *env, jobject obj) |
|
|
sync_handshake_result to_SyncHandshakeResult(JNIEnv *env, |
|
|
{ |
|
|
jobject obj) |
|
|
|
|
|
{ |
|
|
static const char *classname = "foundation/pEp/jniadapter/SyncHandshakeResult"; |
|
|
static const char *classname = "foundation/pEp/jniadapter/SyncHandshakeResult"; |
|
|
jclass clazz_enc_format = findClass(env, classname); |
|
|
jclass clazz_enc_format = findClass(env, classname); |
|
|
jfieldID field_value = env->GetFieldID(clazz_enc_format, "value", "I"); |
|
|
jfieldID field_value = env->GetFieldID(clazz_enc_format, "value", "I"); |
|
|
@ -764,7 +789,7 @@ namespace pEp { |
|
|
|
|
|
|
|
|
env->DeleteLocalRef(clazz_enc_format); |
|
|
env->DeleteLocalRef(clazz_enc_format); |
|
|
return static_cast<sync_handshake_result>(env->GetIntField(obj, field_value)); |
|
|
return static_cast<sync_handshake_result>(env->GetIntField(obj, field_value)); |
|
|
} |
|
|
} |
|
|
}; |
|
|
}; |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
|
heck
5 years ago