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);
}
