FcmPushClient::FcmPushClient()
{
LOG(TRACE) + "FcmPushInit()";
canExecuteNotifications = false;
JNIEnv *env = jnienv();
static jclass cls = rho_find_class(env, s_FCM_FACADE_CLASS);
if (!cls) {
LOG(ERROR) + "Cannot find class: " + s_FCM_FACADE_CLASS;
return;
}
static jmethodID mid = env->GetStaticMethodID(cls, "initFireBase", "()V");
if (!mid) {
LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS + ".initFireBase() method";
return;
}
env->CallStaticVoidMethod(cls, mid);
CMethodResult result;
setProperty("id", s_Type, result);
setProperty("type", IPush::PUSH_TYPE_NATIVE, result);
setProperty("senderId", RHOCONF().getString("Push.fcm.senderId"), result);
setPropertyFromMethod("google_app_id", result);
//setPropertyFromMethod("google_api_key", result);
setPropertyFromMethod("gcm_defaultSenderId", result);
}
extern "C" const char* rho_barcode_barcode_recognize(const char* filename) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return NULL;
jmethodID mid = env->GetStaticMethodID( cls, "recognize", "(Ljava/lang/String;)Ljava/lang/String;");
if (!mid) return NULL;
jstring objFilename = env->NewStringUTF(filename);
jstring res = (jstring)env->CallStaticObjectMethod(cls, mid, objFilename);
env->DeleteLocalRef(objFilename);
if (res == NULL) {
RAWLOG_ERROR("Failed to recognize.");
return NULL;
}
if(env->GetStringUTFLength(res) < (sizeof(barcode_result)/sizeof(barcode_result[0])))
{
const char* code = env->GetStringUTFChars(res,0);
strcpy(barcode_result, code);
env->ReleaseStringUTFChars(res, code);
} else
{
RAWLOG_ERROR("Recognized data is too large.");
return NULL;
}
return barcode_result;
}
extern "C" void Init_Barcode1(void)
{
JNIEnv *env = jnienv();
if(env)
{
jclass barcode1SingletonClass = rho_find_class(env, BARCODE1_SINGLETON_CLASS);
if(!barcode1SingletonClass)
{
RAWLOG_ERROR1("Failed to find java class: %s", BARCODE1_SINGLETON_CLASS);
return;
}
jmethodID midInit = env->GetStaticMethodID(barcode1SingletonClass, "init", "()V");
if(!midInit)
{
RAWLOG_ERROR1("Failed to get method 'init' for java class %s", BARCODE1_SINGLETON_CLASS);
return;
}
env->CallStaticVoidMethod(barcode1SingletonClass, midInit);
Init_RubyAPI_Barcode1();
//Init_JSAPI_Barcode1();
}
else
{
RAWLOG_ERROR("Failed to initialize Barcode1 API: jnienv() is failed");
}
}
// that function return native object used for display Web content :
// UIWebView* for iPhone
// jobject for Android - jobect is android.webkit.WebView class type
// HWND for Windows Mobile
void* RhoNativeViewManager::getWebViewObject(int tab_index) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/rhodes/nativeview/RhoNativeViewManager");
if (!cls) return null;
jmethodID mid = env->GetStaticMethodID( cls, "getWebViewObject", "(I)Landroid/webkit/WebView;");
if (!mid) return null;
return env->CallStaticObjectMethod(cls, mid, tab_index);
}
RHO_GLOBAL double google_mapview_state_center_lon()
{
JNIEnv *env = jnienv();
static jclass cls = rho_find_class(env, GMAP_FACADE_CLASS);
if (!cls) return 0;
jmethodID mid = getJNIClassStaticMethod(env, cls, "getCenterLongitude", "()D");
if (!mid) return 0;
return env->CallStaticDoubleMethod(cls, mid);
}
RHO_GLOBAL void google_mapview_close()
{
JNIEnv *env = jnienv();
static jclass clsMapView = rho_find_class(env, GMAP_FACADE_CLASS);
if (!clsMapView) return;
jmethodID midClose = getJNIClassStaticMethod(env, clsMapView, "close", "()V");
if (!midClose) return;
env->CallStaticVoidMethod(clsMapView, midClose);
}
RHO_GLOBAL VALUE google_mapview_state_started()
{
VALUE nil = rho_ruby_get_NIL();
JNIEnv *env = jnienv();
static jclass cls = rho_find_class(env, GMAP_FACADE_CLASS);
if (!cls) return nil;
jmethodID mid = getJNIClassStaticMethod(env, cls, "isStarted", "()Z");
if (!mid) return nil;
return rho_ruby_create_boolean(env->CallStaticBooleanMethod(cls, mid));
}
extern "C" void rho_barcode_take_barcode(const char* callback) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return;
jmethodID mid = env->GetStaticMethodID( cls, "take", "(Ljava/lang/String;)V");
if (!mid) return;
jstring objCallback = env->NewStringUTF(callback);
env->CallStaticObjectMethod(cls, mid, objCallback);
env->DeleteLocalRef(objCallback);
}
extern "C" VALUE locationmanager_native_process_string(const char* str) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/locationmanager/Locationmanager");
if (!cls) return rho_ruby_get_NIL();;
jmethodID mid = env->GetStaticMethodID( cls, "processString", "(Ljava/lang/String;)Ljava/lang/String;");
if (!mid) return rho_ruby_get_NIL();;
jstring objStr = env->NewStringUTF(str);
jstring jstr = (jstring)env->CallStaticObjectMethod(cls, mid, objStr);
env->DeleteLocalRef(objStr);
const char* buf = env->GetStringUTFChars(jstr,0);
VALUE result = rho_ruby_create_string(buf);
env->ReleaseStringUTFChars(jstr, buf);
return result;
}
RHO_GLOBAL void google_mapview_create(rho_param *p)
{
JNIEnv *env = jnienv();
static jclass clsMapView = rho_find_class(env, GMAP_FACADE_CLASS);
if (!clsMapView) return;
jmethodID midCreate = getJNIClassStaticMethod(env, clsMapView, "create", "(Ljava/util/Map;)V");
if (!midCreate) return;
if (p->type != RHO_PARAM_HASH) {
RAWLOG_ERROR("create: wrong input parameter (expect Hash)");
return;
}
jhobject paramsObj = RhoValueConverter(env).createObject(p);
env->CallStaticVoidMethod(clsMapView, midCreate, paramsObj.get());
}
extern "C" void Init_Development(void)
{
RAWTRACE(__FUNCTION__);
JNIEnv *env = jnienv();
if(env)
{
jclass cls = rho_find_class(env, DEVELOPMENT_FACTORY_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", DEVELOPMENT_FACTORY_CLASS);
return;
}
jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V");
if(!midFactory)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", DEVELOPMENT_FACTORY_CLASS);
return;
}
jobject jFactory = env->NewObject(cls, midFactory);
if(env->IsSameObject(jFactory, NULL))
{
RAWLOG_ERROR1("Failed to create %s instance", DEVELOPMENT_FACTORY_CLASS);
return;
}
RAWTRACE("Initializing Java factory");
rho::CDevelopmentBase::setJavaFactory(env, jFactory);
RAWTRACE("Deleting JNI reference");
env->DeleteLocalRef(jFactory);
RAWTRACE("Initializing API");
Init_Development_API();
RAWTRACE("Init_Development succeeded");
}
else
{
RAWLOG_ERROR("Failed to initialize Development API: jnienv() is failed");
}
}
extern "C" void Init_NativeToolbar(void)
{
RAWTRACE(__FUNCTION__);
JNIEnv *env = jnienv();
if(env)
{
jclass cls = rho_find_class(env, NATIVETOOLBAR_FACTORY_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", NATIVETOOLBAR_FACTORY_CLASS);
return;
}
jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V");
if(!midFactory)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", NATIVETOOLBAR_FACTORY_CLASS);
return;
}
jobject jFactory = env->NewObject(cls, midFactory);
if(env->IsSameObject(jFactory, NULL))
{
RAWLOG_ERROR1("Failed to create %s instance", NATIVETOOLBAR_FACTORY_CLASS);
return;
}
RAWTRACE("Initializing Java factory");
rho::CNativeToolbarBase::setJavaFactory(env, jFactory);
RAWTRACE("Deleting JNI reference");
env->DeleteLocalRef(jFactory);
RAWTRACE("Initializing API");
Init_NativeToolbar_API();
RAWTRACE("Init_NativeToolbar succeeded");
}
else
{
RAWLOG_ERROR("Failed to initialize NativeToolbar API: jnienv() is failed");
}
RHODESAPP().getExtManager().requireRubyFile("RhoNativeToolbarApi");
}
void FcmPushClient::refreshToken(){
LOG(TRACE) + "refreshToken()";
JNIEnv *env = jnienv();
static jclass cls = rho_find_class(env, s_FCM_FACADE_CLASS);
if (!cls) {
LOG(ERROR) + "Cannot find class: " + s_FCM_FACADE_CLASS;
return;
}
static jmethodID mid = env->GetStaticMethodID(cls, "refreshToken", "()V");
if (!mid) {
LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS + ".refreshToken() method";
return;
}
env->CallStaticVoidMethod(cls, mid);
}
//----------------------------------------------------------------------------------------------------------------------
JNIEnv* CBarcode1::jniInit()
{
JNIEnv *env = jnienv();
if(!s_class)
{
s_class = rho_find_class(env, CLASS);
if(!s_class)
{
RAWLOG_ERROR1("Failed to find java class: %s", CLASS);
s_class = 0;
return NULL;
}
s_midEnumerate = env->GetStaticMethodID(s_class, "enumerate", "(V)java/util/List;");
if(!s_midEnumerate)
{
RAWLOG_ERROR1("Failed to get method 'enumerate' for java class %s", CLASS);
s_class = 0;
return NULL;
}
s_midGetDefault = env->GetStaticMethodID(s_class, "getDefault", "()com/rhomobile/rhoelements/IBarcode1;");
if(!s_midGetDefault)
{
RAWLOG_ERROR1("Failed to get method 'getDefault' for java class %s", CLASS);
s_class = 0;
return NULL;
}
s_midSetDefaultID = env->GetStaticMethodID(s_class, "setDefaultID", "(java/util/String;)V");
if(!s_midSetDefaultID)
{
RAWLOG_ERROR1("Failed to get method 'setDefaultID' for java class %s", CLASS);
s_class = 0;
return NULL;
}
s_midCreate = env->GetStaticMethodID(s_class, "create", "(java/util/String;)com/rhomobile/rhoelements/IBarcode1;");
if(!s_midCreate)
{
RAWLOG_ERROR1("Failed to get method 'create' for java class %s", CLASS);
s_class = 0;
return NULL;
}
}
return env;
}
extern "C" void Init_Development_extension() {
Development_Init();
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, DEVELOPMENT_CLASS);
if (!cls) {
RAWLOG_ERROR1("Failed to create %s instance", DEVELOPMENT_CLASS);
return;
}
jmethodID mid = getJNIClassStaticMethod(env, cls, "initExtension", "()V");
if (!mid) {
RAWLOG_ERROR1("Failed to get initExtension() method from %s class", DEVELOPMENT_CLASS);
return;
}
if (already_inited == 0) {
already_inited = 1;
env->CallStaticVoidMethod(cls, mid);
}
}
extern "C" void rho_motobarcode_enumerate(const char* callback) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return;
jmethodID mid = env->GetStaticMethodID( cls, "callMotoEnumerateCallback", "(Ljava/lang/String;)V");
if (!mid) return;
jstring objCallback = env->NewStringUTF(callback);
if(objCallback != NULL)
{
env->CallStaticObjectMethod(cls, mid, objCallback);
env->DeleteLocalRef(objCallback);
}
//VALUE b_array = rho_ruby_create_array();
//rho_ruby_add_to_array(b_array, rho_ruby_create_string("RhoBarcode based on ZXing"));
//return b_array;
}
//----------------------------------------------------------------------------------------------------------------------
void GcmPushClient::doUnregister()
{
LOG(TRACE) + "GcmPushUnregister()";
JNIEnv *env = jnienv();
static jclass cls = rho_find_class(env, s_GCM_FACADE_CLASS);
if (!cls) {
LOG(ERROR) + "Cannot find class: " + s_GCM_FACADE_CLASS;
return;
}
static jmethodID mid = env->GetStaticMethodID(cls, "Unregister", "()V");
if (!mid) {
LOG(ERROR) + "Cannot get " + s_GCM_FACADE_CLASS + ".Unregister() method";
return;
}
env->CallStaticVoidMethod(cls, mid);
}
extern "C" const char* rho_barcode_barcode_recognize(const char* filename) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return NULL;
jmethodID mid = env->GetStaticMethodID( cls, "recognize", "(Ljava/lang/String;)Ljava/lang/String;");
if (!mid) return NULL;
jstring objFilename = env->NewStringUTF(filename);
jstring res = (jstring)env->CallStaticObjectMethod(cls, mid, objFilename);
env->DeleteLocalRef(objFilename);
if (res == NULL) {
return NULL;
}
const char* code = env->GetStringUTFChars(res,0);
strcpy(barcode_result, code);
env->ReleaseStringUTFChars(res, code);
return barcode_result;
}
void FcmPushClient::setPropertyFromMethod(const char* methodName, CMethodResult &result) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, s_FCM_FACADE_CLASS);
if (!cls) {
LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS;
return;
}
jmethodID mid = env->GetStaticMethodID( cls, methodName, "()Ljava/lang/String;");
if (!mid){
LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS + "." + methodName + " method";
return;
}
jstring jstr = (jstring)env->CallStaticObjectMethod(cls, mid);
const char* buf = env->GetStringUTFChars(jstr,0);
setProperty(methodName, buf, result);
env->ReleaseStringUTFChars(jstr, buf);
}
extern "C" void Init_Barcode1(void)
{
RAWTRACE("Init_Barcode1");
JNIEnv *env = jnienv();
if(env)
{
jclass cls = rho_find_class(env, BARCODE1_FACTORY_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", BARCODE1_FACTORY_CLASS);
return;
}
jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V");
if(!midFactory)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", BARCODE1_FACTORY_CLASS);
return;
}
jobject jFactory = env->NewObject(cls, midFactory);
if(env->IsSameObject(jFactory, NULL))
{
RAWLOG_ERROR1("Failed to create %s instance", BARCODE1_FACTORY_CLASS);
return;
}
rhoelements::CBarcode1::setJavaFactory(env, jFactory);
env->DeleteLocalRef(jFactory);
Init_Barcode1_API();
RAWTRACE("Init_Barcode1 succeeded");
}
else
{
RAWLOG_ERROR("Failed to initialize Barcode1 API: jnienv() is failed");
}
}
//----------------------------------------------------------------------------------------------------------------------
void GcmPushClient::doRegister()
{
LOG(TRACE) + "GcmPushRegister()";
JNIEnv *env = jnienv();
static jclass cls = rho_find_class(env, s_GCM_FACADE_CLASS);
if (!cls) {
LOG(ERROR) + "Cannot find class: " + s_GCM_FACADE_CLASS;
return;
}
static jmethodID mid = env->GetStaticMethodID(cls, "Register", "(Ljava/lang/String;)V");
if (!mid) {
LOG(ERROR) + "Cannot get " + s_GCM_FACADE_CLASS + ".Register() method";
return;
}
jhstring jhSenderId = rho_cast<jstring>(m_hashProps["senderId"]);
env->CallStaticVoidMethod(cls, mid, jhSenderId.get());
}
extern "C" void elemez_native_raiseDisruption(const char* sender, const char* source, int userInitiated) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/elemez/Elemez");
if (!cls) {
return;
}
jmethodID mid = env->GetStaticMethodID(cls, "raiseDisruption", "(Ljava/lang/String;Ljava/lang/String;Z)V");
if (!mid) {
return;
}
jstring objSender = env->NewStringUTF(sender);
jstring objSource = env->NewStringUTF(source);
jboolean objUserInitiated = userInitiated == 1 ? JNI_TRUE : JNI_FALSE;
env->CallStaticObjectMethod(cls, mid, objSender, objSource, objUserInitiated);
env->DeleteLocalRef(objSender);
env->DeleteLocalRef(objSource);
}
JNIEnv* MethodExecutorJni::jniInit()
{
JNIEnv *env = jnienv();
if(env && !s_MethodExecutorClass)
{
s_MethodExecutorClass = rho_find_class(env, METHOD_EXECUTOR_CLASS);
if(!s_MethodExecutorClass)
{
RAWLOG_ERROR1("Failed to find java class: %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
s_midRun = env->GetStaticMethodID(s_MethodExecutorClass, "run", "(Ljava/lang/Runnable;)V");
if(!s_midRun)
{
RAWLOG_ERROR1("Failed to get method 'run' for java class %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
s_midRunWithSeparateThread = env->GetStaticMethodID(s_MethodExecutorClass, "runWithSeparateThread", "(Ljava/lang/Runnable;)V");
if(!s_midRunWithSeparateThread)
{
RAWLOG_ERROR1("Failed to get method 'runWithSeparateThread' for java class %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
s_midRunWithUiThread = env->GetStaticMethodID(s_MethodExecutorClass, "runWithUiThread", "(Ljava/lang/Runnable;)V");
if(!s_midRunWithUiThread)
{
RAWLOG_ERROR1("Failed to get method 'runWithUiThread' for java class %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
}
return env;
}
extern "C" void rho_barcode_take_barcode(const char* callback, VALUE options) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return;
jmethodID mid = env->GetStaticMethodID( cls, "take", "(Ljava/lang/String;I)V");
if (!mid) return;
int camera_index = 0;
if (!rho_ruby_is_NIL(options)) {
// parse options for camera index ( 0 - main, 1 - front)
rho_param *param = rho_param_fromvalue(options);
if (param->type == RHO_PARAM_HASH) {
int i;
for (i = 0; i < param->v.hash->size; i++) {
if (strcasecmp(param->v.hash->name[i], "camera") == 0) {
if (param->v.hash->value[i]->type == RHO_PARAM_STRING) {
if (strcasecmp(param->v.hash->value[i]->v.string, "front") == 0) {
camera_index = 1;
}
}
}
}
}
rho_param_free(param);
}
jstring objCallback = env->NewStringUTF(callback);
if(objCallback != NULL)
{
env->CallStaticObjectMethod(cls, mid, objCallback, camera_index);
env->DeleteLocalRef(objCallback);
} else
{
RAWLOG_ERROR1("Cannot take barcode, no memory: %d", strlen(callback));
}
}
JNIEnv* CBarcode1::jniInit()
{
JNIEnv *env = MethodExecutorJni::jniInit();
if(env && !s_singletonClass)
{
jclass clsBase = rho_find_class(env, SINGLETON_BASE_CLASS);
if(!clsBase)
{
RAWLOG_ERROR1("Failed to find java class: %s", SINGLETON_BASE_CLASS);
s_singletonClass = 0;
return NULL;
}
s_singletonBaseClass = static_cast<jclass>(env->NewGlobalRef(clsBase));
env->DeleteLocalRef(clsBase);
jclass cls = rho_find_class(env, SINGLETON_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", SINGLETON_CLASS);
s_singletonClass = 0;
return NULL;
}
s_singletonClass = static_cast<jclass>(env->NewGlobalRef(cls));
env->DeleteLocalRef(cls);
s_midGetInstance = env->GetStaticMethodID(s_singletonBaseClass, "getInstance", "()Lcom/motorolasolutions/rhoelements/Barcode1SingletonBase;");
if(!s_midGetInstance)
{
RAWLOG_ERROR1("Failed to get method 'getInstance' for java class %s", SINGLETON_BASE_CLASS);
s_singletonClass = 0;
return NULL;
}
s_midEnumerate = env->GetMethodID(s_singletonClass, "enumerate", "(Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midEnumerate)
{
RAWLOG_ERROR1("Failed to get method 'enumerate' for java class %s", SINGLETON_CLASS);
s_singletonClass = 0;
return NULL;
}
s_midGetDefaultID = env->GetMethodID(s_singletonClass, "getDefaultID", "()Ljava/lang/String;");
if(!s_midGetDefaultID)
{
RAWLOG_ERROR1("Failed to get method 'getDefaultID' for java class %s", SINGLETON_CLASS);
s_singletonClass = 0;
return NULL;
}
s_midSetDefaultID = env->GetMethodID(s_singletonClass, "setDefaultID", "(Ljava/lang/String;)V");
if(!s_midSetDefaultID)
{
RAWLOG_ERROR1("Failed to get method 'setDefaultID' for java class %s", SINGLETON_CLASS);
s_singletonClass = 0;
return NULL;
}
s_midGetApiObject = env->GetMethodID(s_singletonClass, "getApiObject", "(Ljava/lang/String;)Lcom/motorolasolutions/rhoelements/IBarcode1;");
if(!s_midGetApiObject)
{
RAWLOG_ERROR1("Failed to get method 'getApiObject' for java class %s", SINGLETON_CLASS);
s_singletonClass = 0;
return NULL;
}
jclass clsTask = rho_find_class(env, GETPROPS_TASK_CLASS);
if(!clsTask)
{
RAWLOG_ERROR1("Failed to find java class: %s", GETPROPS_TASK_CLASS);
s_singletonClass = 0;
return NULL;
}
s_getPropsTaskClass = static_cast<jclass>(env->NewGlobalRef(clsTask));
env->DeleteLocalRef(clsTask);
s_midGetPropsTask = env->GetMethodID(s_getPropsTaskClass, "<init>",
"(Lcom/motorolasolutions/rhoelements/IBarcode1;Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midGetPropsTask)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", GETPROPS_TASK_CLASS);
s_singletonClass = 0;
return NULL;
}
jclass clsTask1 = rho_find_class(env, GETPROPS1_TASK_CLASS);
if(!clsTask1)
{
RAWLOG_ERROR1("Failed to find java class: %s", GETPROPS1_TASK_CLASS);
s_singletonClass = 0;
return NULL;
}
s_getProps1TaskClass = static_cast<jclass>(env->NewGlobalRef(clsTask1));
env->DeleteLocalRef(clsTask1);
s_midGetProps1Task = env->GetMethodID(s_getProps1TaskClass, "<init>",
"(Lcom/motorolasolutions/rhoelements/IBarcode1;Ljava/lang/String;Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midGetProps1Task)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", GETPROPS1_TASK_CLASS);
s_singletonClass = 0;
return NULL;
}
jclass clsTask2 = rho_find_class(env, GETPROPS2_TASK_CLASS);
if(!clsTask2)
{
RAWLOG_ERROR1("Failed to find java class: %s", GETPROPS2_TASK_CLASS);
s_singletonClass = 0;
return NULL;
}
s_getProps2TaskClass = static_cast<jclass>(env->NewGlobalRef(clsTask2));
env->DeleteLocalRef(clsTask2);
s_midGetProps2Task = env->GetMethodID(s_getProps2TaskClass, "<init>",
"(Lcom/motorolasolutions/rhoelements/IBarcode1;Ljava/util/List;Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midGetProps2Task)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", GETPROPS2_TASK_CLASS);
s_singletonClass = 0;
return NULL;
}
}
return env;
}
JNIEnv* MethodResultJni::jniInit()
{
JNIEnv *env = jnienv();
if(env && !s_methodResultClass)
{
jclass cls = rho_find_class(env, METHOD_RESULT_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_methodResultClass = static_cast<jclass>(env->NewGlobalRef(cls));
env->DeleteLocalRef(cls);
s_midMethodResult = env->GetMethodID(s_methodResultClass, "<init>", "()V");
if(!s_midMethodResult)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_midSetCallBack = env->GetMethodID(s_methodResultClass, "setCallBack", "(Ljava/lang/String;Ljava/lang/String;)V");
if(!s_midSetCallBack)
{
RAWLOG_ERROR1("Failed to get method 'setCallback' for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_midGetResultType = env->GetMethodID(s_methodResultClass, "getResultType", "()I");
if(!s_midGetResultType)
{
RAWLOG_ERROR1("Failed to get method 'getResultType' for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_midReset = env->GetMethodID(s_methodResultClass, "reset", "()V");
if(!s_midReset)
{
RAWLOG_ERROR1("Failed to get method 'reset' for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_fidBoolean = env->GetFieldID(s_methodResultClass, "mBooleanResult", "Z");
if(!s_fidBoolean)
{
RAWLOG_ERROR1("Failed to get 'mBooleanResult' field for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_fidInteger = env->GetFieldID(s_methodResultClass, "mIntegerResult", "I");
if(!s_fidInteger)
{
RAWLOG_ERROR1("Failed to get 'mIntegerResult' field for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_fidDouble = env->GetFieldID(s_methodResultClass, "mDoubleResult", "D");
if(!s_fidDouble)
{
RAWLOG_ERROR1("Failed to get 'mDoubleResult' field for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_fidString = env->GetFieldID(s_methodResultClass, "mStrResult", "Ljava/lang/String;");
if(!s_fidString)
{
RAWLOG_ERROR1("Failed to get 'mStrResult' field for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_fidStringList = env->GetFieldID(s_methodResultClass, "mListResult", "Ljava/util/List;");
if(!s_fidStringList)
{
RAWLOG_ERROR1("Failed to get 'mListResult' field for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
s_fidStringMap = env->GetFieldID(s_methodResultClass, "mMapResult", "Ljava/util/Map;");
if(!s_fidStringMap)
{
RAWLOG_ERROR1("Failed to get 'mMapResult' field for java class %s", METHOD_RESULT_CLASS);
s_methodResultClass = 0;
return NULL;
}
}
return env;
}
