static void findClasses(JNIEnv *env) { ompi_java.CartParmsClass = findClass(env, "mpi/CartParms"); ompi_java.ShiftParmsClass = findClass(env, "mpi/ShiftParms"); ompi_java.GraphParmsClass = findClass(env, "mpi/GraphParms"); ompi_java.DistGraphNeighborsClass = findClass( env, "mpi/DistGraphNeighbors"); ompi_java.StatusClass = findClass(env, "mpi/Status"); ompi_java.ExceptionClass = findClass(env, "mpi/MPIException"); ompi_java.ExceptionInit = (*env)->GetMethodID( env, ompi_java.ExceptionClass, "<init>", "(IILjava/lang/String;)V"); ompi_java.IntegerClass = findClass(env, "java/lang/Integer"); ompi_java.LongClass = findClass(env, "java/lang/Long"); ompi_java.IntegerValueOf = (*env)->GetStaticMethodID( env, ompi_java.IntegerClass, "valueOf", "(I)Ljava/lang/Integer;"); ompi_java.LongValueOf = (*env)->GetStaticMethodID( env, ompi_java.LongClass, "valueOf", "(J)Ljava/lang/Long;"); }
// TheTransportRegistry::get_config jobject JNICALL Java_OpenDDS_DCPS_transport_TheTransportRegistry_get_1config (JNIEnv * jni, jclass, jstring name) { JStringMgr jsm_name(jni, name); try { OpenDDS::DCPS::TransportConfig_rch config = TheTransportRegistry->get_config(jsm_name.c_str()); jclass configClazz = findClass(jni, "OpenDDS/DCPS/transport/TransportConfig"); jmethodID ctor = jni->GetMethodID(configClazz, "<init>", "(J)V"); return jni->NewObject(configClazz, ctor, reinterpret_cast<jlong>(config._retn())); } catch (const CORBA::SystemException &se) { throw_java_exception(jni, se); return 0; } catch (const OpenDDS::DCPS::Transport::Exception &te) { throw_java_exception(jni, te); return 0; } }
int jniRegisterNativeMethods(JNIEnv* env, const char* className, const JNINativeMethod* gMethods, int numMethods) { // my_log("Registering %s natives", className); my_log("Registering natives"); jclass clazz= findClass(env, className); if(clazz==NULL){ my_log("clazz==NULL"); return -1; } /** * jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods); */ if ((*env)->RegisterNatives(env, clazz, gMethods, numMethods) < 0) { // my_log("RegisterNatives failed for '%s'", className); my_log("RegisterNatives failed for "); return -1; } return 0; }
float Jvm::getStaticField<float>(const JField& field) { return env->GetStaticFloatField(findClass(field.clazz), field.id); }
double Jvm::getStaticField<double>(const JField& field) { return env->GetStaticDoubleField(findClass(field.clazz), field.id); }
zsLib::String CacheDelegateWrapper::fetch(const char *cookieNamePath) { jclass cls; jmethodID method; jobject object; JNIEnv *jni_env = 0; jstring cookieJavaString; const char *fetchedStr; __android_log_print(ANDROID_LOG_DEBUG, "com.openpeer.jni", "Cache fetch called - cookieNamePath = %s", cookieNamePath); bool attached = false; switch (android_jvm->GetEnv((void**)&jni_env, JNI_VERSION_1_6)) { case JNI_OK: break; case JNI_EDETACHED: if (android_jvm->AttachCurrentThread(&jni_env, NULL)!=0) { throw std::runtime_error("Could not attach current thread"); } attached = true; break; case JNI_EVERSION: throw std::runtime_error("Invalid java version"); } cookieJavaString = jni_env->NewStringUTF(cookieNamePath); if (javaDelegate != NULL) { //get delegate implementation class name in order to get method String className = OpenPeerCoreManager::getObjectClassName(javaDelegate); jclass callbackClass = findClass(className.c_str()); method = jni_env->GetMethodID(callbackClass, "fetch", "(Ljava/lang/String;)Ljava/lang/String;"); object = jni_env->CallObjectMethod(javaDelegate, method, cookieJavaString); cls = findClass("java/lang/String"); if(jni_env->IsInstanceOf(object, cls) == JNI_TRUE) { fetchedStr = jni_env->GetStringUTFChars((jstring)object, NULL); } } else { __android_log_print(ANDROID_LOG_ERROR, "com.openpeer.jni", "Cache fetch Java delegate is NULL !!!"); } if (jni_env->ExceptionCheck()) { jni_env->ExceptionDescribe(); } if (attached) { android_jvm->DetachCurrentThread(); } return fetchedStr; }
JNIEXPORT void JNICALL Java_shmem_ShMem_init(JNIEnv *env, jclass clazz) { shmem_java.ExceptionClass = findClass(env, "shmem/ShMemException"); }
ClassMethodMap constructMethodMap( QString const & className ) const { return constructMethodMap(findClass(className)); }
/* readClass reads a class method description */ static void readMethods(FILE* fd, bool printit) { ObjectHandle classObj, methTable, theMethod, selector; # define LINEBUFFERSIZE 16384 char *cp, *eoftest, lineBuffer[LINEBUFFERSIZE]; ObjectHandle protocol; Parser pp; lineBuffer[0] = '\0'; protocol = nilobj; if (ll.nextToken() != nameconst) sysError("missing name","following Method keyword"); classObj = findClass(ll.strToken().c_str()); pp.setInstanceVariables(classObj); if (printit) cp = objectRef(classObj->basicAt(nameInClass)).charPtr(); /* now find or create a method table */ methTable = classObj->basicAt(methodsInClass); if (methTable == nilobj) { /* must make */ methTable = newDictionary(MethodTableSize); classObj->basicAtPut(methodsInClass, methTable); } if(ll.nextToken() == strconst) { protocol = newStString(ll.strToken().c_str()); } /* now go read the methods */ do { if (lineBuffer[0] == '|') /* get any left over text */ strcpy(textBuffer,&lineBuffer[1]); else textBuffer[0] = '\0'; while((eoftest = fgets(lineBuffer, LINEBUFFERSIZE, fd)) != NULL) { if ((lineBuffer[0] == '|') || (lineBuffer[0] == ']')) break; strcat(textBuffer, lineBuffer); } if (eoftest == NULL) { sysError("unexpected end of file","while reading method"); break; } /* now we have a method */ theMethod = newMethod(); pp.setLexer(Lexer(textBuffer)); if (pp.parseMessageHandler(theMethod, savetext)) { selector = theMethod->basicAt(messageInMethod); theMethod->basicAtPut(methodClassInMethod, classObj); theMethod->basicAtPut(protocolInMethod, protocol); if (printit) dspMethod(cp, selector->charPtr()); nameTableInsert(methTable, selector.hash(), selector, theMethod); } else { /* get rid of unwanted method */ givepause(); } } while (lineBuffer[0] != ']'); }
double Jvm::invokeStaticV<double>(const JClass& receiver, const jmethodID id, va_list args) { return env->CallStaticDoubleMethodV(findClass(receiver), id, args); }
string keywordNew(MavenCompiler* c, string entity, string element, string args, string& type) { string rawType = stripRawType(entity); int depth = ((element != "") ? 1 : 0); //cout << "entity = '" << entity << "', element = '" << element << "', args = '" << args << "', line = " << c->lineNumber << endl; // if this is a native type StringList types; MavenMutability mut; if(isDataType(rawType)) { type = appendArrayDepth(c, rawType, depth); string r = "new maven::" + rawType + "Array(" + dissectCode(c, element, types, mut) + ")"; // bug #54: make sure types is 'int' return r; } // first make sure the class exists bool isEnum = false; type = appendArrayDepth(c, findMavenObjectPath(c, trim(entity)), depth); if(stripRawType(type) == MAVEN_INVALID) { if(enumExists(c, stripRawType(entity))) { isEnum = true; type = c->currentNamespace + "." + appendArrayDepth(c, entity, depth); } else { pushError(c, "Unknown class '%s'", stripRawType(type)); return MAVEN_INVALID; } } int namespaceID, objectID; findClass(c, entity, namespaceID, objectID); smartAssert(namespaceID >= 0); smartAssert(objectID >= 0); // if its a single Object if(element == "") { string r = "new "; r += c->namespaces->at(namespaceID).name + "::" + c->namespaces->at(namespaceID).objects->at(objectID)->name; for(int i = 0; i < depth; ++i) r += "*"; // args is assumed to be predissected. return r + "(" + args + ")"; } else { string elements = dissectCode(c, element, types, mut); // bug #54: make sure types is 'int' string r = "new maven::"; if(isEnum) { r += "int"; rawType = "int"; int nID = findNamespaceID(c, c->currentNamespace); smartAssert(nID >= 0); int enumID = findEnumID(c, nID, entity); smartAssert(enumID >= 0); if(trim(args) == "") args = intToString(c->namespaces->at(nID).enums[enumID].getDefaultValue()); } else r += "object"; string tempVar = getNextTempVariable(c); if(isDataType(rawType)) c->beforeLine += rawType + "* " + tempVar + " = new " + rawType + "[" + elements + "];\n"; else c->beforeLine += "maven::Object** " + tempVar + " = new maven::Object*[" + elements + "];\n"; c->beforeLine += "for(int __INIT = 0; __INIT < " + elements + "; ++__INIT)\n"; if(isDataType(rawType)) { if(trim(args) == "") args = "0"; c->beforeLine += tempVar + "[__INIT] = " + args + ";\n"; } else c->beforeLine += tempVar + "[__INIT] = (maven::Object*) new " + rawType + "(" + args + ");\n"; r += "Array(" + elements + "," + tempVar + ")"; return r; } }
long Jvm::invokeStaticV<long>(const JClass& receiver, const jmethodID id, va_list args) { return env->CallStaticLongMethodV(findClass(receiver), id, args); }
float Jvm::invokeStaticV<float>(const JClass& receiver, const jmethodID id, va_list args) { return env->CallStaticFloatMethodV(findClass(receiver), id, args); }
char Jvm::invokeStaticV<char>(const JClass& receiver, const jmethodID id, va_list args) { return env->CallStaticCharMethodV(findClass(receiver), id, args); }
bool Jvm::invokeStaticV<bool>(const JClass& receiver, const jmethodID id, va_list args) { return env->CallStaticBooleanMethodV(findClass(receiver), id, args); }
void Jvm::invokeStaticV<void>(const JClass& receiver, const jmethodID id, va_list args) { env->CallStaticVoidMethodV(findClass(receiver), id, args); }
/* readClass reads a class method description */ static void readMethods(FILE *fd, boolean printit) { object classObj, methTable, theMethod, selector; # define LINEBUFFERSIZE 512 char *cp, *eoftest, lineBuffer[LINEBUFFERSIZE]; if (nextToken() != nameconst) sysError("missing name", "following Method keyword"); classObj = findClass(tokenString); setInstanceVariables(classObj); if (printit) cp = charPtr(basicAt(classObj, nameInClass)); /* now find or create a method table */ methTable = basicAt(classObj, methodsInClass); if (methTable == nilobj) /* must make */ { methTable = newDictionary(MethodTableSize); basicAtPut(classObj, methodsInClass, methTable); } /* now go read the methods */ do { if (lineBuffer[0] == '|') /* get any left over text */ strcpy(textBuffer, &lineBuffer[1]); else textBuffer[0] = '\0'; while ((eoftest = fgets(lineBuffer, LINEBUFFERSIZE, fd)) != NULL) { if ((lineBuffer[0] == '|') || (lineBuffer[0] == ']')) break; strcat(textBuffer, lineBuffer); } if (eoftest == NULL) { sysError("unexpected end of file", "while reading method"); break; } /* now we have a method */ theMethod = newMethod(); if (parse(theMethod, textBuffer, savetext)) { selector = basicAt(theMethod, messageInMethod); basicAtPut(theMethod, methodClassInMethod, classObj); if (printit) dspMethod(cp, charPtr(selector)); nameTableInsert(methTable, (int) selector, selector, theMethod); } else { /* get rid of unwanted method */ incr(theMethod); decr(theMethod); givepause(); } } while (lineBuffer[0] != ']'); }
jobject Jvm::getStaticField<jobject>(const JField& field) { jobject result = env->GetStaticObjectField(findClass(field.clazz), field.id); assure(result != NULL,env); return result; }
jobjectArray SunJVMDLL::newObjectArray(int size, const std::string& classname, jobject initialValue) { jclass cls = findClass(classname); return newObjectArray(size, cls, initialValue); }
bool Jvm::getStaticField<bool>(const JField& field) { return env->GetStaticBooleanField(findClass(field.clazz), field.id); }
void ClassLattice::joinLattice( ClassLattice * lattTo ) //----------------------------------------------------- { ClassList* list = _flatClasses; ClassList adjust; int levelDiff = 0; bool levelSet = FALSE; int i; REQUIRE( lattTo != this, "classlattice::joinlattice -- join to myself" ); for( i = 0; i < list->count(); i += 1 ) { ClassLattice * node = (*list)[ i ]; if( node != NULL ) { adjust.add( node ); for( int j = node->_bases.count(); j > 0; j -= 1 ) { DerivationPtr * basePtr = node->_bases[ j - 1 ]; REQUIRE( node->_flatClasses != lattTo->_flatClasses, "ClassLattice::JoinLattice tried to join related" ); int index = findClass( *lattTo->_flatClasses, basePtr->_class ); if( index >= 0 ) { //NYI rely on not having loaded deriveds (otherwise, might kill me!) REQUIRE( !basePtr->_class->_derivedsLoaded, "joinLattice ack" ); list->replaceAt( findClass( *list, basePtr->_class ), NULL ); if( basePtr->_class != (*lattTo->_flatClasses)[ index ] ) { delete basePtr->_class; // this should probably be a separate function // what it is doing is changing all of the pointers // from basePtr->_class to the same class in lattTo for( int k = list->count(); k > 0; k -= 1 ) { ClassLattice * work = (*list)[ k - 1 ]; if( work != NULL ) { for( int l = work->_bases.count(); l > 0; l -= 1 ) { if( work->_bases[ l - 1 ]->_class == basePtr->_class ) { work->_bases[ l - 1 ]->adjustTo( (*lattTo->_flatClasses)[ index ] ); int tryDiff = work->_bases[ l - 1 ]->_class->_level + 1 - work->_level; if( !levelSet ) { levelDiff = tryDiff; levelSet = TRUE; } else { if( tryDiff > levelDiff ) { levelDiff = tryDiff; } } } } } } } } } node->_flatClasses = lattTo->_flatClasses; lattTo->_flatClasses->add( node ); } } for( i = adjust.count(); i > 0; i -= 1 ) { adjust[ i - 1 ]->_level += levelDiff; } delete list; }
char Jvm::getStaticField<char>(const JField& field) { return env->GetStaticCharField(findClass(field.clazz), field.id); }
void JNIUtil::initCache() { LOG_TIMER(TAG, "initializing JNI cache"); JNIEnv *env = JNIScope::getEnv(); classClass = findClass("java/lang/Class"); objectClass = findClass("java/lang/Object"); numberClass = findClass("java/lang/Number"); stringClass = findClass("java/lang/String"); shortClass = findClass("java/lang/Short"); integerClass = findClass("java/lang/Integer"); longClass = findClass("java/lang/Long"); floatClass = findClass("java/lang/Float"); doubleClass = findClass("java/lang/Double"); booleanClass = findClass("java/lang/Boolean"); shortArrayClass = findClass("[S"); intArrayClass = findClass("[I"); longArrayClass = findClass("[J"); floatArrayClass = findClass("[F"); doubleArrayClass = findClass("[D"); booleanArrayClass = findClass("[Z"); objectArrayClass = findClass("[Ljava/lang/Object;"); arrayListClass = findClass("java/util/ArrayList"); hashMapClass = findClass("java/util/HashMap"); dateClass = findClass("java/util/Date"); setClass = findClass("java/util/Set"); outOfMemoryError = findClass("java/lang/OutOfMemoryError"); nullPointerException = findClass("java/lang/NullPointerException"); throwableClass = findClass("java/lang/Throwable"); v8ObjectClass = findClass("org/appcelerator/kroll/runtime/v8/V8Object"); v8FunctionClass = findClass("org/appcelerator/kroll/runtime/v8/V8Function"); krollRuntimeClass = findClass("org/appcelerator/kroll/KrollRuntime"); krollInvocationClass = findClass("org/appcelerator/kroll/KrollInvocation"); krollObjectClass = findClass("org/appcelerator/kroll/KrollObject"); krollProxyClass = findClass("org/appcelerator/kroll/KrollProxy"); krollAssetHelperClass = findClass("org/appcelerator/kroll/util/KrollAssetHelper"); krollLoggingClass = findClass("org/appcelerator/kroll/KrollLogging"); tiJsErrorDialogClass = findClass("org/appcelerator/kroll/common/TiJSErrorDialog"); referenceTableClass = findClass("org/appcelerator/kroll/runtime/v8/ReferenceTable"); classGetNameMethod = getMethodID(classClass, "getName", "()Ljava/lang/String;", false); arrayListInitMethod = getMethodID(arrayListClass, "<init>", "()V", false); arrayListAddMethod = getMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z", false); arrayListGetMethod = getMethodID(arrayListClass, "get", "(I)Ljava/lang/Object;", false); arrayListRemoveMethod = getMethodID(arrayListClass, "remove", "(I)Ljava/lang/Object;", false); hashMapInitMethod = getMethodID(hashMapClass, "<init>", "(I)V", false); hashMapGetMethod = getMethodID(hashMapClass, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false); hashMapPutMethod = getMethodID(hashMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", false); hashMapKeySetMethod = getMethodID(hashMapClass, "keySet", "()Ljava/util/Set;", false); hashMapRemoveMethod = getMethodID(hashMapClass, "remove", "(Ljava/lang/Object;)Ljava/lang/Object;", false); setToArrayMethod = getMethodID(setClass, "toArray", "()[Ljava/lang/Object;", false); dateInitMethod = getMethodID(dateClass, "<init>", "(J)V", false); dateGetTimeMethod = getMethodID(dateClass, "getTime", "()J", false); integerInitMethod = getMethodID(integerClass, "<init>", "(I)V", false); doubleInitMethod = getMethodID(doubleClass, "<init>", "(D)V", false); booleanInitMethod = getMethodID(booleanClass, "<init>", "(Z)V", false); booleanBooleanValueMethod = getMethodID(booleanClass, "booleanValue", "()Z", false); longInitMethod = getMethodID(longClass, "<init>", "(J)V", false); numberDoubleValueMethod = getMethodID(numberClass, "doubleValue", "()D", false); throwableGetMessageMethod = getMethodID(throwableClass, "getMessage", "()Ljava/lang/String;", false); v8ObjectPtrField = getFieldID(v8ObjectClass, "ptr", "J"); v8ObjectInitMethod = getMethodID(v8ObjectClass, "<init>", "(J)V", false); v8FunctionInitMethod = getMethodID(v8FunctionClass, "<init>", "(J)V", false); referenceTableCreateReferenceMethod = getMethodID(referenceTableClass, "createReference", "(Ljava/lang/Object;)I", true); referenceTableDestroyReferenceMethod = getMethodID(referenceTableClass, "destroyReference", "(I)V", true); referenceTableMakeWeakReferenceMethod = getMethodID(referenceTableClass, "makeWeakReference", "(I)V", true); referenceTableClearWeakReferenceMethod = getMethodID(referenceTableClass, "clearWeakReference", "(I)Ljava/lang/Object;", true); referenceTableGetReferenceMethod = getMethodID(referenceTableClass, "getReference", "(I)Ljava/lang/Object;", true); jfieldID dontInterceptField = env->GetStaticFieldID(krollRuntimeClass, "DONT_INTERCEPT", "I"); krollRuntimeDontIntercept = env->GetStaticIntField(krollRuntimeClass, dontInterceptField); krollInvocationInitMethod = getMethodID(krollInvocationClass, "<init>", "(Ljava/lang/String;)V", false); krollObjectSetHasListenersForEventTypeMethod = getMethodID(krollObjectClass, "setHasListenersForEventType", "(Ljava/lang/String;Z)V"); krollObjectOnEventFiredMethod = getMethodID(krollObjectClass, "onEventFired", "(Ljava/lang/String;Ljava/lang/Object;)V"); const char *createProxySignature = "(Ljava/lang/Class;Lorg/appcelerator/kroll/KrollObject;[Ljava/lang/Object;Ljava/lang/String;)Lorg/appcelerator/kroll/KrollProxy;"; krollProxyCreateProxyMethod = getMethodID(krollProxyClass, "createProxy", createProxySignature, true); krollProxyCreateDeprecatedProxyMethod = getMethodID(krollProxyClass, "createDeprecatedProxy", createProxySignature, true); krollProxyKrollObjectField = getFieldID(krollProxyClass, "krollObject", "Lorg/appcelerator/kroll/KrollObject;"); krollProxyModelListenerField = getFieldID(krollProxyClass, "modelListener", "Lorg/appcelerator/kroll/KrollProxyListener;"); krollProxySetIndexedPropertyMethod = getMethodID(krollProxyClass, "setIndexedProperty", "(ILjava/lang/Object;)V"); krollProxyGetIndexedPropertyMethod = getMethodID(krollProxyClass, "getIndexedProperty", "(I)Ljava/lang/Object;"); krollProxyOnPropertyChangedMethod = getMethodID(krollProxyClass, "onPropertyChanged", "(Ljava/lang/String;Ljava/lang/Object;)V"); krollProxyOnPropertiesChangedMethod = getMethodID(krollProxyClass, "onPropertiesChanged", "([[Ljava/lang/Object;)V", false); openErrorDialogMethod = getMethodID(tiJsErrorDialogClass, "openErrorDialog", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;I)V",true); krollAssetHelperReadAssetMethod = getMethodID(krollAssetHelperClass, "readAsset", "(Ljava/lang/String;)Ljava/lang/String;", true); krollAssetHelperFileExistsMethod = getMethodID(krollAssetHelperClass, "fileExists", "(Ljava/lang/String;)Z", true); krollLoggingLogWithDefaultLoggerMethod = getMethodID(krollLoggingClass, "logWithDefaultLogger", "(ILjava/lang/String;)V", true); jfieldID undefinedObjectField = env->GetStaticFieldID(krollRuntimeClass, "UNDEFINED", "Ljava/lang/Object;"); undefinedObject = env->NewGlobalRef(env->GetStaticObjectField(krollRuntimeClass, undefinedObjectField)); }
JNIEXPORT jobject JNICALL Java_org_ocera_orte_Publication_jORTEPublicationGetStatus (JNIEnv *env, jobject obj, jlong j_appDomain_handle) { // jni types jclass cls_ps = NULL; // class of PubStatus jobject obj_ps = NULL; // instance of PubStatus jfieldID fid = NULL; jmethodID mid = NULL; // int b = 0; // boolean int flag_ok = 0; ORTEPublStatus ps; ORTEPublStatus *publ_stat = &ps; #ifdef TEST_STAGE printf(":c: ORTEPublicationGetStatus() called.. \n"); #endif do { // call ORTE function b = ORTEPublicationGetStatus((ORTEPublication *)j_appDomain_handle, publ_stat); if (b == ORTE_BAD_HANDLE) { printf(":!c: publicationGetStatus() failed! [bad pub handle] \n"); break; } // find cls cls_ps = findClass(env, "org.ocera.orte.types.Status"); if (cls_ps == 0) { #ifdef TEST_STAGE printf(":!c: cls_ps = NULL \n"); #endif break; } // call object constructor mid = (*env)->GetMethodID(env, cls_ps, "<init>", "()V"); if (mid == 0) { #ifdef TEST_STAGE printf(":!c: mid = NULL \n"); #endif break; } // new object obj_ps = (*env)->NewObject(env, cls_ps, mid); if (obj_ps == 0) { #ifdef TEST_STAGE printf(":!c: obj_ps = NULL \n"); #endif break; } // /////////////////////////////////////////////// // setting object's fields // fieldID - strict fid = (*env)->GetFieldID(env, cls_ps, "strict", "J"); if (fid == NULL) { #ifdef TEST_STAGE printf(":!c: fid = NULL \n"); #endif break; } (*env)->SetLongField(env, obj_ps, fid, (jlong)publ_stat->strict); // fieldID - bestEffort fid = (*env)->GetFieldID(env, cls_ps, "bestEffort", "J"); if (fid == NULL) { #ifdef TEST_STAGE printf(":!c: fid = NULL \n"); #endif break; } (*env)->SetLongField(env, obj_ps, fid, (jlong)publ_stat->bestEffort); // fieldID - issues fid = (*env)->GetFieldID(env, cls_ps, "issues", "J"); if (fid == NULL) { #ifdef TEST_STAGE printf(":!c: fid = NULL \n"); #endif break; } (*env)->SetLongField(env, obj_ps, fid, (jlong)publ_stat->issues); // set flag flag_ok = 1; } while (0); if (flag_ok == 0) { return NULL; } return obj_ps; }
void CacheDelegateWrapper::store(const char *cookieNamePath, Time expires, const char *str) { jclass cls; jmethodID method; jobject object; JNIEnv *jni_env = 0; jstring cookieJavaString; jstring storeStr; String expStr = openpeer::services::IHelper::timeToString(expires); __android_log_print(ANDROID_LOG_DEBUG, "com.openpeer.jni", "Cache store called - cookieNamePath = %s",cookieNamePath); bool attached = false; switch (android_jvm->GetEnv((void**)&jni_env, JNI_VERSION_1_6)) { case JNI_OK: break; case JNI_EDETACHED: if (android_jvm->AttachCurrentThread(&jni_env, NULL)!=0) { throw std::runtime_error("Could not attach current thread"); } attached = true; break; case JNI_EVERSION: throw std::runtime_error("Invalid java version"); } cookieJavaString = jni_env->NewStringUTF(cookieNamePath); storeStr = jni_env->NewStringUTF(str); jclass timeCls = findClass("android/text/format/Time"); jmethodID timeMethodID = jni_env->GetMethodID(timeCls, "<init>", "()V"); object = jni_env->NewObject(timeCls, timeMethodID); if (Time() != expires) { jmethodID timeSetMillisMethodID = jni_env->GetMethodID(timeCls, "set", "(J)V"); //Convert and set time from C++ to Android; Fetch methods needed to accomplish this Time time_t_epoch = boost::posix_time::time_from_string("1970-01-01 00:00:00.000"); //calculate and set Expires Time zsLib::Duration closedTimeDuration = expires - time_t_epoch; jni_env->CallVoidMethod(object, timeSetMillisMethodID, closedTimeDuration.total_milliseconds()); } if (javaDelegate != NULL) { //get delegate implementation class name in order to get method String className = OpenPeerCoreManager::getObjectClassName(javaDelegate); jclass callbackClass = findClass(className.c_str()); method = jni_env->GetMethodID(callbackClass, "store", "(Ljava/lang/String;Landroid/text/format/Time;Ljava/lang/String;)V"); jni_env->CallVoidMethod(javaDelegate, method, cookieJavaString, object, storeStr); } else { __android_log_print(ANDROID_LOG_ERROR, "com.openpeer.jni", "Cache store Java delegate is NULL !!!"); } if (jni_env->ExceptionCheck()) { jni_env->ExceptionDescribe(); } if(attached) { android_jvm->DetachCurrentThread(); } }
JavaJSImpl::JavaJSImpl(const char *appserverPath) { _jvm = 0; _mainEnv = 0; _dbhook = 0; stringstream ss; string edTemp; const char * ed = 0; ss << "-Djava.class.path=."; if ( appserverPath ) { ed = findEd(appserverPath); assert( ed ); ss << SYSTEM_COLON << ed << "/build/"; _addClassPath( ed , ss , "include" ); _addClassPath( ed , ss , "include/jython/" ); _addClassPath( ed , ss , "include/jython/javalib" ); } else { const string jars = findJars(); _addClassPath( jars.c_str() , ss , "jars" ); edTemp += (string)jars + "/jars/mongojs-js.jar"; ed = edTemp.c_str(); } #if defined(_WIN32) ss << SYSTEM_COLON << "C:\\Program Files\\Java\\jdk\\lib\\tools.jar"; #else ss << SYSTEM_COLON << "/opt/java/lib/tools.jar"; #endif if ( getenv( "CLASSPATH" ) ) ss << SYSTEM_COLON << getenv( "CLASSPATH" ); string s = ss.str(); char * p = (char *)malloc( s.size() * 4 ); strcpy( p , s.c_str() ); char *q = p; #if defined(_WIN32) while ( *p ) { if ( *p == '/' ) *p = '\\'; p++; } #endif log(1) << "classpath: " << q << endl; JavaVMOption * options = new JavaVMOption[4]; options[0].optionString = q; options[1].optionString = (char*)"-Djava.awt.headless=true"; options[2].optionString = (char*)"-Xmx300m"; // Prevent JVM from using async signals internally, since on linux the pre-installed handlers for these // signals don't seem to be respected by JNI. options[3].optionString = (char*)"-Xrs"; // -Xcheck:jni _vmArgs = new JavaVMInitArgs(); _vmArgs->version = JNI_VERSION_1_4; _vmArgs->options = options; _vmArgs->nOptions = 4; _vmArgs->ignoreUnrecognized = JNI_FALSE; log(1) << "loading JVM" << endl; jint res = JNI_CreateJavaVM( &_jvm, (void**)&_mainEnv, _vmArgs ); if ( res ) { log() << "using classpath: " << q << endl; log() << " res : " << (unsigned) res << " " << "_jvm : " << _jvm << " " << "_env : " << _mainEnv << " " << endl; problem() << "Couldn't create JVM res:" << (int) res << " terminating" << endl; log() << "(try --nojni if you do not require that functionality)" << endl; exit(22); } jassert( res == 0 ); jassert( _jvm > 0 ); jassert( _mainEnv > 0 ); _envs = new boost::thread_specific_ptr<JNIEnv>( myJNIClean ); assert( ! _envs->get() ); _envs->reset( _mainEnv ); _dbhook = findClass( "ed/db/JSHook" ); if ( _dbhook == 0 ) { log() << "using classpath: " << q << endl; printException(); } jassert( _dbhook ); if ( ed ) { jmethodID init = _mainEnv->GetStaticMethodID( _dbhook , "init" , "(Ljava/lang/String;)V" ); jassert( init ); _mainEnv->CallStaticVoidMethod( _dbhook , init , _getEnv()->NewStringUTF( ed ) ); } _dbjni = findClass( "ed/db/DBJni" ); jassert( _dbjni ); _scopeCreate = _mainEnv->GetStaticMethodID( _dbhook , "scopeCreate" , "()J" ); _scopeInit = _mainEnv->GetStaticMethodID( _dbhook , "scopeInit" , "(JLjava/nio/ByteBuffer;)Z" ); _scopeSetThis = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetThis" , "(JLjava/nio/ByteBuffer;)Z" ); _scopeReset = _mainEnv->GetStaticMethodID( _dbhook , "scopeReset" , "(J)Z" ); _scopeFree = _mainEnv->GetStaticMethodID( _dbhook , "scopeFree" , "(J)V" ); _scopeGetNumber = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetNumber" , "(JLjava/lang/String;)D" ); _scopeGetString = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetString" , "(JLjava/lang/String;)Ljava/lang/String;" ); _scopeGetBoolean = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetBoolean" , "(JLjava/lang/String;)Z" ); _scopeGetType = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetType" , "(JLjava/lang/String;)B" ); _scopeGetObject = _mainEnv->GetStaticMethodID( _dbhook , "scopeGetObject" , "(JLjava/lang/String;Ljava/nio/ByteBuffer;)I" ); _scopeGuessObjectSize = _mainEnv->GetStaticMethodID( _dbhook , "scopeGuessObjectSize" , "(JLjava/lang/String;)J" ); _scopeSetNumber = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetNumber" , "(JLjava/lang/String;D)Z" ); _scopeSetBoolean = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetBoolean" , "(JLjava/lang/String;Z)Z" ); _scopeSetString = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetString" , "(JLjava/lang/String;Ljava/lang/String;)Z" ); _scopeSetObject = _mainEnv->GetStaticMethodID( _dbhook , "scopeSetObject" , "(JLjava/lang/String;Ljava/nio/ByteBuffer;)Z" ); _functionCreate = _mainEnv->GetStaticMethodID( _dbhook , "functionCreate" , "(Ljava/lang/String;)J" ); _invoke = _mainEnv->GetStaticMethodID( _dbhook , "invoke" , "(JJ)I" ); jassert( _scopeCreate ); jassert( _scopeInit ); jassert( _scopeSetThis ); jassert( _scopeReset ); jassert( _scopeFree ); jassert( _scopeGetNumber ); jassert( _scopeGetString ); jassert( _scopeGetObject ); jassert( _scopeGetBoolean ); jassert( _scopeGetType ); jassert( _scopeGuessObjectSize ); jassert( _scopeSetNumber ); jassert( _scopeSetBoolean ); jassert( _scopeSetString ); jassert( _scopeSetObject ); jassert( _functionCreate ); jassert( _invoke ); JNINativeMethod * nativeSay = new JNINativeMethod(); nativeSay->name = (char*)"native_say"; nativeSay->signature = (char*)"(Ljava/nio/ByteBuffer;)V"; nativeSay->fnPtr = (void*)java_native_say; _mainEnv->RegisterNatives( _dbjni , nativeSay , 1 ); JNINativeMethod * nativeCall = new JNINativeMethod(); nativeCall->name = (char*)"native_call"; nativeCall->signature = (char*)"(Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)I"; nativeCall->fnPtr = (void*)java_native_call; _mainEnv->RegisterNatives( _dbjni , nativeCall , 1 ); }
short Jvm::getStaticField<short>(const JField& field) { return env->GetStaticShortField(findClass(field.clazz), field.id); }
void BackgroundingDelegateWrapper::onBackgroundingGoingToBackgroundNow( IBackgroundingSubscriptionPtr subscription ) { jclass cls; jmethodID method; jobject object; JNIEnv *jni_env = 0; __android_log_print(ANDROID_LOG_DEBUG, "com.openpeer.jni", "onBackgroundingGoingToBackgroundNow called"); bool attached = false; switch (android_jvm->GetEnv((void**)&jni_env, JNI_VERSION_1_6)) { case JNI_OK: break; case JNI_EDETACHED: if (android_jvm->AttachCurrentThread(&jni_env, NULL)!=0) { throw std::runtime_error("Could not attach current thread"); } attached = true; break; case JNI_EVERSION: throw std::runtime_error("Invalid java version"); } if (javaDelegate != NULL) { //get delegate implementation class name in order to get method String className = OpenPeerCoreManager::getObjectClassName(javaDelegate); //create new OPBackgroundingSubscription java object cls = findClass("com/openpeer/javaapi/OPBackgroundingSubscription"); method = jni_env->GetMethodID(cls, "<init>", "()V"); jobject subsciptionObject = jni_env->NewObject(cls, method); //fill new field with pointer to core pointer IBackgroundingSubscriptionPtr* ptrToSubscription = new boost::shared_ptr<IBackgroundingSubscription>(subscription); jfieldID fid = jni_env->GetFieldID(cls, "nativeClassPointer", "J"); jni_env->SetLongField(subsciptionObject, fid, (jlong)ptrToSubscription); jclass callbackClass = findClass(className.c_str()); method = jni_env->GetMethodID(callbackClass, "onBackgroundingGoingToBackgroundNow", "(Lcom/openpeer/javaapi/OPBackgroundingSubscription;)V"); jni_env->CallVoidMethod(javaDelegate, method, subsciptionObject); } else { __android_log_print(ANDROID_LOG_ERROR, "com.openpeer.jni", "onBackgroundingGoingToBackgroundNow Java delegate is NULL !!!"); } if (jni_env->ExceptionCheck()) { jni_env->ExceptionDescribe(); } if(attached) { android_jvm->DetachCurrentThread(); } }
void JniConstants::init(JNIEnv* env) { bidiRunClass = findClass(env, "java/text/Bidi$Run"); bigDecimalClass = findClass(env, "java/math/BigDecimal"); booleanClass = findClass(env, "java/lang/Boolean"); byteClass = findClass(env, "java/lang/Byte"); byteArrayClass = findClass(env, "[B"); charsetICUClass = findClass(env, "java/nio/charset/CharsetICU"); constructorClass = findClass(env, "java/lang/reflect/Constructor"); deflaterClass = findClass(env, "java/util/zip/Deflater"); doubleClass = findClass(env, "java/lang/Double"); errnoExceptionClass = findClass(env, "libcore/io/ErrnoException"); fieldClass = findClass(env, "java/lang/reflect/Field"); fieldPositionIteratorClass = findClass(env, "libcore/icu/NativeDecimalFormat$FieldPositionIterator"); fileDescriptorClass = findClass(env, "java/io/FileDescriptor"); gaiExceptionClass = findClass(env, "libcore/io/GaiException"); inet6AddressClass = findClass(env, "java/net/Inet6Address"); inetAddressClass = findClass(env, "java/net/InetAddress"); inetSocketAddressClass = findClass(env, "java/net/InetSocketAddress"); inflaterClass = findClass(env, "java/util/zip/Inflater"); integerClass = findClass(env, "java/lang/Integer"); localeDataClass = findClass(env, "libcore/icu/LocaleData"); longClass = findClass(env, "java/lang/Long"); methodClass = findClass(env, "java/lang/reflect/Method"); mutableIntClass = findClass(env, "libcore/util/MutableInt"); mutableLongClass = findClass(env, "libcore/util/MutableLong"); parsePositionClass = findClass(env, "java/text/ParsePosition"); patternSyntaxExceptionClass = findClass(env, "java/util/regex/PatternSyntaxException"); realToStringClass = findClass(env, "java/lang/RealToString"); socketClass = findClass(env, "java/net/Socket"); socketImplClass = findClass(env, "java/net/SocketImpl"); stringArrayClass = findClass(env, "[Ljava/lang/String;"); stringClass = findClass(env, "java/lang/String"); structAddrinfoClass = findClass(env, "libcore/io/StructAddrinfo"); structFlockClass = findClass(env, "libcore/io/StructFlock"); structGroupReqClass = findClass(env, "libcore/io/StructGroupReq"); structLingerClass = findClass(env, "libcore/io/StructLinger"); structPasswdClass = findClass(env, "libcore/io/StructPasswd"); structPollfdClass = findClass(env, "libcore/io/StructPollfd"); structStatClass = findClass(env, "libcore/io/StructStat"); structStatFsClass = findClass(env, "libcore/io/StructStatFs"); structTimevalClass = findClass(env, "libcore/io/StructTimeval"); structUtsnameClass = findClass(env, "libcore/io/StructUtsname"); }
long Jvm::getStaticField<long>(const JField& field) { return env->GetStaticLongField(findClass(field.clazz), field.id); }