Esempio n. 1
0
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;");
}
Esempio n. 2
0
// 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;
  }
}
Esempio n. 3
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;
}
Esempio n. 4
0
float Jvm::getStaticField<float>(const JField& field)
{
  return env->GetStaticFloatField(findClass(field.clazz), field.id);
}
Esempio n. 5
0
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;
}
Esempio n. 7
0
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));
 }
Esempio n. 9
0
/*
    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] != ']');

}
Esempio n. 10
0
double Jvm::invokeStaticV<double>(const JClass& receiver,
                                  const jmethodID id,
                                  va_list args)
{
  return env->CallStaticDoubleMethodV(findClass(receiver), id, args);
}
Esempio n. 11
0
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;
	}
}
Esempio n. 12
0
long Jvm::invokeStaticV<long>(const JClass& receiver,
                              const jmethodID id,
                              va_list args)
{
  return env->CallStaticLongMethodV(findClass(receiver), id, args);
}
Esempio n. 13
0
float Jvm::invokeStaticV<float>(const JClass& receiver,
                                const jmethodID id,
                                va_list args)
{
  return env->CallStaticFloatMethodV(findClass(receiver), id, args);
}
Esempio n. 14
0
char Jvm::invokeStaticV<char>(const JClass& receiver,
                              const jmethodID id,
                              va_list args)
{
  return env->CallStaticCharMethodV(findClass(receiver), id, args);
}
Esempio n. 15
0
bool Jvm::invokeStaticV<bool>(const JClass& receiver,
                              const jmethodID id,
                              va_list args)
{
  return env->CallStaticBooleanMethodV(findClass(receiver), id, args);
}
Esempio n. 16
0
void Jvm::invokeStaticV<void>(const JClass& receiver,
                              const jmethodID id,
                              va_list args)
{
  env->CallStaticVoidMethodV(findClass(receiver), id, args);
}
Esempio n. 17
0
/*
 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] != ']');
}
Esempio n. 18
0
jobject Jvm::getStaticField<jobject>(const JField& field)
{
  jobject result = env->GetStaticObjectField(findClass(field.clazz), field.id);
  assure(result != NULL,env);
  return result;
}
Esempio n. 19
0
jobjectArray  SunJVMDLL::newObjectArray(int size, const std::string& classname, jobject initialValue)
{
  jclass cls = findClass(classname);
  return newObjectArray(size, cls, initialValue);
}
Esempio n. 20
0
bool Jvm::getStaticField<bool>(const JField& field)
{
  return env->GetStaticBooleanField(findClass(field.clazz), field.id);
}
Esempio n. 21
0
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;
}
Esempio n. 22
0
char Jvm::getStaticField<char>(const JField& field)
{
  return env->GetStaticCharField(findClass(field.clazz), field.id);
}
Esempio n. 23
0
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));
}
Esempio n. 24
0
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;

}
Esempio n. 25
0
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();
	}
}
Esempio n. 26
0
    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 );

    }
Esempio n. 27
0
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();
	}
}
Esempio n. 29
0
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");
}
Esempio n. 30
0
long Jvm::getStaticField<long>(const JField& field)
{
  return env->GetStaticLongField(findClass(field.clazz), field.id);
}