static int _open_uri(const String& p_uri) {
JNIEnv *env = ThreadAndroid::get_env();
jstring jStr = env->NewStringUTF(p_uri.utf8().get_data());
return env->CallIntMethod(godot_io,_openURI,jStr) ;
}
static String _get_data_dir() {
JNIEnv *env = ThreadAndroid::get_env();
jstring s =(jstring)env->CallObjectMethod(godot_io,_getDataDir);
return String(env->GetStringUTFChars( s, NULL ));
}
//--------------------------------------------------------
/// Create Native Interface
//--------------------------------------------------------
void IJavaInterface::CreateNativeInterface(const std::string& instrInterfaceName)
{
if (mpJavaObject == nullptr)
{
JNIEnv* pEnv = JavaInterfaceManager::GetSingletonPtr()->GetJNIEnvironmentPtr();
//get the class type
jclass jClassType = JavaVirtualMachine::Get()->FindClass(instrInterfaceName);
if (jClassType == nullptr)
{
jthrowable exception = pEnv->ExceptionOccurred();
if (exception != nullptr)
{
pEnv->ExceptionDescribe();
pEnv->ExceptionClear();
}
CS_LOG_FATAL("Cannot find native interface class '" + instrInterfaceName + "'");
}
//get the class instance
jmethodID jConstructor = pEnv->GetMethodID(jClassType, "<init>", "()V");
jobject jClassInstance = pEnv->NewObject(jClassType, jConstructor);
if (jClassInstance == nullptr)
{
jthrowable exception = pEnv->ExceptionOccurred();
if (exception != nullptr)
{
pEnv->ExceptionDescribe();
pEnv->ExceptionClear();
}
CS_LOG_FATAL("Cannot create native interface instance '" + instrInterfaceName + "'");
}
//create a global reference to the instance
mpJavaObject = pEnv->NewGlobalRef(jClassInstance);
//delete all the local references
pEnv->DeleteLocalRef(jClassType);
pEnv->DeleteLocalRef(jClassInstance);
}
else
{
CS_LOG_FATAL("Cannot create native interface " + instrInterfaceName + ", as it has already been created!");
}
}
virtual Variant call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error) {
//print_line("attempt to call "+String(p_method));
ERR_FAIL_COND_V(!instance,Variant());
r_error.error=Variant::CallError::CALL_OK;
Map<StringName,MethodData >::Element *E=method_map.find(p_method);
if (!E) {
print_line("no exists");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
return Variant();
}
int ac = E->get().argtypes.size();
if (ac<p_argcount) {
print_line("fewargs");
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=ac;
return Variant();
}
if (ac>p_argcount) {
print_line("manyargs");
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=ac;
return Variant();
}
for(int i=0;i<p_argcount;i++) {
if (!Variant::can_convert(p_args[i]->get_type(),E->get().argtypes[i])) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=i;
r_error.expected=E->get().argtypes[i];
}
}
jvalue *v=NULL;
if (p_argcount) {
v=(jvalue*)alloca( sizeof(jvalue)*p_argcount );
}
JNIEnv *env = ThreadAndroid::get_env();
//print_line("argcount "+String::num(p_argcount));
for(int i=0;i<p_argcount;i++) {
v[i] = _variant_to_jvalue(env, E->get().argtypes[i], p_args[i]);
}
//print_line("calling method!!");
Variant ret;
switch(E->get().ret_type) {
case Variant::NIL: {
//print_line("call void");
env->CallVoidMethodA(instance,E->get().method,v);
} break;
case Variant::BOOL: {
ret = env->CallBooleanMethodA(instance,E->get().method,v);
//print_line("call bool");
} break;
case Variant::INT: {
ret = env->CallIntMethodA(instance,E->get().method,v);
//print_line("call int");
} break;
case Variant::REAL: {
ret = env->CallFloatMethodA(instance,E->get().method,v);
} break;
case Variant::STRING: {
jobject o = env->CallObjectMethodA(instance,E->get().method,v);
String str = env->GetStringUTFChars((jstring)o, NULL );
ret=str;
} break;
case Variant::STRING_ARRAY: {
jobjectArray arr = (jobjectArray)env->CallObjectMethodA(instance,E->get().method,v);
ret = _jobject_to_variant(env, arr);
} break;
case Variant::INT_ARRAY: {
jintArray arr = (jintArray)env->CallObjectMethodA(instance,E->get().method,v);
int fCount = env->GetArrayLength(arr);
DVector<int> sarr;
sarr.resize(fCount);
DVector<int>::Write w = sarr.write();
env->GetIntArrayRegion(arr,0,fCount,w.ptr());
w = DVector<int>::Write();
ret=sarr;
} break;
case Variant::REAL_ARRAY: {
jfloatArray arr = (jfloatArray)env->CallObjectMethodA(instance,E->get().method,v);
int fCount = env->GetArrayLength(arr);
DVector<float> sarr;
sarr.resize(fCount);
DVector<float>::Write w = sarr.write();
env->GetFloatArrayRegion(arr,0,fCount,w.ptr());
w = DVector<float>::Write();
ret=sarr;
} break;
case Variant::DICTIONARY: {
//print_line("call dictionary");
jobject obj = env->CallObjectMethodA(instance, E->get().method, v);
ret = _jobject_to_variant(env, obj);
} break;
default: {
print_line("failure..");
ERR_FAIL_V(Variant());
} break;
}
//print_line("success");
return ret;
}
void JniOnObserveListener::onObserveCallback(const HeaderOptions headerOptions,
const OCRepresentation& ocRepresentation, const int& eCode, const int& sequenceNumber)
{
jint envRet;
JNIEnv *env = GetJNIEnv(envRet);
if (NULL == env) return;
jobject jListener = env->NewLocalRef(m_jwListener);
if (!jListener)
{
checkExAndRemoveListener(env);
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
return;
}
jclass clsL = env->GetObjectClass(jListener);
if (!clsL)
{
checkExAndRemoveListener(env);
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
return;
}
if (OC_STACK_OK != eCode && OC_STACK_RESOURCE_CREATED != eCode && OC_STACK_RESOURCE_DELETED != eCode)
{
jobject ex = GetOcException(eCode, "stack error in onObserveCallback");
if (!ex)
{
checkExAndRemoveListener(env);
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
return;
}
jmethodID midL = env->GetMethodID(clsL, "onObserveFailed", "(Ljava/lang/Throwable;)V");
if (!midL)
{
checkExAndRemoveListener(env);
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
return;
}
env->CallVoidMethod(jListener, midL, ex);
}
else
{
jobject jHeaderOptionList = JniUtils::convertHeaderOptionsVectorToJavaList(env, headerOptions);
if (!jHeaderOptionList)
{
checkExAndRemoveListener(env);
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
return;
}
OCRepresentation * rep = new OCRepresentation(ocRepresentation);
jlong handle = reinterpret_cast<jlong>(rep);
jobject jRepresentation = env->NewObject(g_cls_OcRepresentation,
g_mid_OcRepresentation_N_ctor_bool, handle, true);
if (!jRepresentation)
{
delete rep;
checkExAndRemoveListener(env);
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
return;
}
jmethodID midL = env->GetMethodID(clsL, "onObserveCompleted",
"(Ljava/util/List;Lorg/iotivity/base/OcRepresentation;I)V");
if (!midL)
{
checkExAndRemoveListener(env);
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
return;
}
env->CallVoidMethod(jListener, midL, jHeaderOptionList, jRepresentation,
static_cast<jint>(sequenceNumber));
if (env->ExceptionCheck())
{
LOGE("Java exception is thrown");
delete rep;
jthrowable ex = env->ExceptionOccurred();
env->ExceptionClear();
m_ownerResource->removeOnObserveListener(env, m_jwListener);
env->Throw((jthrowable)ex);
}
}
if (JNI_EDETACHED == envRet) g_jvm->DetachCurrentThread();
}
void onGetMyProfile(long requestId, bool success, ProfileItem item, string errnum, string errmsg) {
FileLog("httprequest", "Profile.Native::onGetMyProfile( success : %s )", success?"true":"false");
/* turn object to java object here */
JNIEnv* env;
jint iRet = JNI_ERR;
gJavaVM->GetEnv((void**)&env, JNI_VERSION_1_4);
if( env == NULL ) {
iRet = gJavaVM->AttachCurrentThread((JNIEnv **)&env, NULL);
}
jobject jItem = NULL;
JavaItemMap::iterator itr = gJavaItemMap.find(PROFILE_ITEM_CLASS);
if( itr != gJavaItemMap.end() ) {
jclass cls = env->GetObjectClass(itr->second);
if( cls != NULL) {
jmethodID init = env->GetMethodID(cls, "<init>", "("
"Ljava/lang/String;"
"I"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"I"
"Ljava/lang/String;"
"Ljava/lang/String;"
"I"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"I"
"I"
"Ljava/lang/String;"
"I"
"Ljava/lang/String;"
"I"
"I"
"Ljava/lang/String;"
"I"
"Ljava/lang/String;"
"I"
"Ljava/util/ArrayList;"
")V"
);
FileLog("httprequest", "Profile.Native::onGetMyProfile( GetMethodID <init> : %p )", init);
if( init != NULL ) {
jstring manid = env->NewStringUTF(item.manid.c_str());
jstring birthday = env->NewStringUTF(item.birthday.c_str());
jstring firstname = env->NewStringUTF(item.firstname.c_str());
jstring lastname = env->NewStringUTF(item.lastname.c_str());
jstring email = env->NewStringUTF(item.email.c_str());
jstring resume = env->NewStringUTF(item.resume.c_str());
jstring resume_content = env->NewStringUTF(item.resume_content.c_str());
jstring address1 = env->NewStringUTF(item.address1.c_str());
jstring address2 = env->NewStringUTF(item.address2.c_str());
jstring city = env->NewStringUTF(item.city.c_str());
jstring province = env->NewStringUTF(item.province.c_str());
jstring zipcode = env->NewStringUTF(item.zipcode.c_str());
jstring telephone = env->NewStringUTF(item.telephone.c_str());
jstring fax = env->NewStringUTF(item.fax.c_str());
jstring alternate_email = env->NewStringUTF(item.alternate_email.c_str());
jstring money = env->NewStringUTF(item.money.c_str());
jstring photoURL = env->NewStringUTF(item.photoURL.c_str());
jstring mobile = env->NewStringUTF(item.mobile.c_str());
jstring landline = env->NewStringUTF(item.landline.c_str());
jstring landline_ac = env->NewStringUTF(item.landline_ac.c_str());
jclass jArrayList = env->FindClass("java/util/ArrayList");
jmethodID jArrayListInit = env->GetMethodID(jArrayList, "<init>", "()V");
jmethodID jArrayListAdd = env->GetMethodID(jArrayList, "add", "(Ljava/lang/Object;)Z");
FileLog("httprequest", "Profile.Native::onGetMyProfile( "
"jArrayList : %p, "
"jArrayListInit : %p, "
"jArrayListAdd : %p "
")",
jArrayList,
jArrayListInit,
jArrayListAdd
);
FileLog("httprequest", "Profile.Native::onGetMyProfile( "
"item.interests.size() : %d "
")",
item.interests.size()
);
int i = 0;
jobject jInterestList = NULL;
jInterestList = env->NewObject(jArrayList, jArrayListInit);
if( item.interests.size() > 0 ) {
i = 0;
for(list<string>::iterator itr = item.interests.begin(); itr != item.interests.end(); itr++, i++) {
jstring value = env->NewStringUTF((*itr).c_str());
env->CallBooleanMethod(jInterestList, jArrayListAdd, value);
env->DeleteLocalRef(value);
}
}
jItem = env->NewObject(cls, init,
manid,
item.age,
birthday,
firstname,
lastname,
email,
item.gender,
item.country,
item.marry,
item.height,
item.weight,
item.smoke,
item.drink,
item.language,
item.religion,
item.education,
item.profession,
item.ethnicity,
item.income,
item.children,
resume,
resume_content,
item.resume_status,
address1,
address2,
city,
province,
zipcode,
telephone,
fax,
alternate_email,
money,
item.v_id,
item.photo,
photoURL,
item.integral,
mobile,
item.mobile_cc,
item.mobile_status,
landline,
item.landline_cc,
landline_ac,
item.landline_status,
jInterestList
);
FileLog("httprequest", "Profile.Native::onGetMyProfile( NewObject : %p )", jItem);
env->DeleteLocalRef(manid);
env->DeleteLocalRef(birthday);
env->DeleteLocalRef(firstname);
env->DeleteLocalRef(lastname);
env->DeleteLocalRef(email);
env->DeleteLocalRef(resume);
env->DeleteLocalRef(resume_content);
env->DeleteLocalRef(address1);
env->DeleteLocalRef(address2);
env->DeleteLocalRef(city);
env->DeleteLocalRef(province);
env->DeleteLocalRef(zipcode);
env->DeleteLocalRef(telephone);
env->DeleteLocalRef(fax);
env->DeleteLocalRef(alternate_email);
env->DeleteLocalRef(money);
env->DeleteLocalRef(photoURL);
env->DeleteLocalRef(mobile);
env->DeleteLocalRef(landline);
env->DeleteLocalRef(landline_ac);
if( jInterestList != NULL ) {
env->DeleteLocalRef(jInterestList);
}
}
}
}
/* real callback java */
jobject callbackObj = gCallbackMap.Erase(requestId);
jclass callbackCls = env->GetObjectClass(callbackObj);
string signure = "(ZLjava/lang/String;Ljava/lang/String;";
signure += "L";
signure += PROFILE_ITEM_CLASS;
signure += ";";
signure += ")V";
jmethodID callback = env->GetMethodID(callbackCls, "OnGetMyProfile", signure.c_str());
FileLog("httprequest", "onGetMyProfile( callbackCls : %p, callback : %p, signure : %s )",
callbackCls, callback, signure.c_str());
if( callbackObj != NULL && callback != NULL ) {
jstring jerrno = env->NewStringUTF(errnum.c_str());
jstring jerrmsg = env->NewStringUTF(errmsg.c_str());
FileLog("httprequest", "Profile.Native::onGetMyProfile( CallObjectMethod "
"jItem : %p )", jItem);
env->CallVoidMethod(callbackObj, callback, success, jerrno, jerrmsg, jItem);
env->DeleteGlobalRef(callbackObj);
env->DeleteLocalRef(jerrno);
env->DeleteLocalRef(jerrmsg);
}
if( jItem != NULL ) {
env->DeleteLocalRef(jItem);
}
if( iRet == JNI_OK ) {
gJavaVM->DetachCurrentThread();
}
}
void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, unsigned short type, int handlerId){
JNIEnv * curEnv = NULL;
jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
jclass cls = curEnv->FindClass( className().c_str() );
jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[ICI)V" ) ;
if (voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID == NULL) {
throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
}
jstring varName_ = curEnv->NewStringUTF( varName );
if (varName != NULL && varName_ == NULL)
{
throw GiwsException::JniBadAllocException(curEnv);
}
jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
if (indexes_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID ,varName_, indexes_, type, handlerId);
curEnv->DeleteLocalRef(varName_);
curEnv->DeleteLocalRef(indexes_);
curEnv->DeleteLocalRef(cls);
if (curEnv->ExceptionCheck()) {
throw GiwsException::JniCallMethodException(curEnv);
}
}
static const TCHAR *
detect_language()
{
#ifdef ANDROID
JNIEnv *env = Java::GetEnv();
Java::Class cls(env, "java/util/Locale");
// Call static function Locale.getDefault() that
// returns the user's default Locale object
jmethodID cid = env->GetStaticMethodID(cls, "getDefault",
"()Ljava/util/Locale;");
assert(cid != NULL);
jobject _obj = env->CallStaticObjectMethod(cls, cid);
if (_obj == NULL)
return NULL;
Java::LocalObject obj(env, _obj);
// Call function Locale.getLanguage() that
// returns a two-letter language string
cid = env->GetMethodID(cls, "getLanguage", "()Ljava/lang/String;");
assert(cid != NULL);
jstring language = (jstring)env->CallObjectMethod(obj, cid);
if (language == NULL)
return NULL;
// Convert the jstring to a char string
const char *language2 = env->GetStringUTFChars(language, NULL);
if (language2 == NULL) {
env->DeleteLocalRef(language);
return NULL;
}
/* generate the resource name */
const char *language3 = language2;
if (strcmp(language3, "pt") == 0)
/* hack */
language3 = "pt_BR";
// Attach .mo to the language identifier
static char language_buffer[16];
snprintf(language_buffer, sizeof(language_buffer), "%s.mo", language3);
// Clean up the memory
env->ReleaseStringUTFChars(language, language2);
env->DeleteLocalRef(language);
// Return e.g. "de.mo"
return language_buffer;
#else /* !ANDROID */
#if defined(_WIN32_WCE)
/* the GetUserDefaultUILanguage() prototype is missing on
mingw32ce, we have to look it up dynamically */
DynamicLibrary coreloc_dll(_T("coredll"));
if (!coreloc_dll.IsDefined()) {
LogStartUp(_T("Language: coredll.dll not found"));
return NULL;
}
typedef LANGID WINAPI (*GetUserDefaultUILanguage_t)();
GetUserDefaultUILanguage_t GetUserDefaultUILanguage =
(GetUserDefaultUILanguage_t)
coreloc_dll.Lookup(_T("GetUserDefaultUILanguage"));
if (GetUserDefaultUILanguage == NULL) {
LogStartUp(_T("Language: GetUserDefaultUILanguage() not available"));
return NULL;
}
#endif
// Retrieve the default user language identifier from the OS
LANGID lang_id = GetUserDefaultUILanguage();
LogStartUp(_T("Language: GetUserDefaultUILanguage()=0x%x"), (int)lang_id);
if (lang_id == 0)
return NULL;
// Try to convert the primary language part of the language identifier
// to a MO file name in the language table
return find_language(PRIMARYLANGID(lang_id));
#endif /* !ANDROID */
}
void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, bool const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
JNIEnv * curEnv = NULL;
jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
jclass cls = curEnv->FindClass( className().c_str() );
jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[ZZI)V" ) ;
if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID == NULL) {
throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
}
jstring varName_ = curEnv->NewStringUTF( varName );
if (varName != NULL && varName_ == NULL)
{
throw GiwsException::JniBadAllocException(curEnv);
}
jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
if (indexes_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[Z"),NULL);
for (int i=0; i<dataSize; i++){
jbooleanArray dataLocal = curEnv->NewBooleanArray( dataSizeCol ) ;
curEnv->SetBooleanArrayRegion( dataLocal, 0, dataSizeCol, (jboolean*)(data[i]) ) ;
curEnv->SetObjectArrayElement(data_, i, dataLocal);
curEnv->DeleteLocalRef(dataLocal);
}
jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
curEnv->DeleteLocalRef(varName_);
curEnv->DeleteLocalRef(indexes_);
curEnv->DeleteLocalRef(data_);
curEnv->DeleteLocalRef(cls);
if (curEnv->ExceptionCheck()) {
throw GiwsException::JniCallMethodException(curEnv);
}
}
void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, char const* const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
JNIEnv * curEnv = NULL;
jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
jclass cls = curEnv->FindClass( className().c_str() );
jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[Ljava/lang/String;ZI)V" ) ;
if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID == NULL) {
throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
}
jstring varName_ = curEnv->NewStringUTF( varName );
if (varName != NULL && varName_ == NULL)
{
throw GiwsException::JniBadAllocException(curEnv);
}
jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
if (indexes_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
jclass stringArrayClass = curEnv->FindClass("java/lang/String");
// create java array of array of strings.
jobjectArray data_ = curEnv->NewObjectArray( dataSize, curEnv->FindClass("[Ljava/lang/String;"), NULL);
if (data_ == NULL)
{
throw GiwsException::JniBadAllocException(curEnv);
}
for ( int i = 0; i < dataSize; i++)
{
jobjectArray dataLocal = curEnv->NewObjectArray( dataSizeCol, stringArrayClass, NULL);
// convert each char * to java strings and fill the java array.
for ( int j = 0; j < dataSizeCol; j++) {
jstring TempString = curEnv->NewStringUTF( data[i][j] );
if (TempString == NULL)
{
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetObjectArrayElement( dataLocal, j, TempString);
// avoid keeping reference on to many strings
curEnv->DeleteLocalRef(TempString);
}
curEnv->SetObjectArrayElement(data_, i, dataLocal);
curEnv->DeleteLocalRef(dataLocal);
}
jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
curEnv->DeleteLocalRef(stringArrayClass);
curEnv->DeleteLocalRef(varName_);
curEnv->DeleteLocalRef(indexes_);
curEnv->DeleteLocalRef(data_);
curEnv->DeleteLocalRef(cls);
if (curEnv->ExceptionCheck()) {
throw GiwsException::JniCallMethodException(curEnv);
}
}
// Constructors
ScilabVariables::ScilabVariables(JavaVM * jvm_) {
jmethodID constructObject = NULL ;
jobject localInstance ;
jclass localClass ;
const std::string construct="<init>";
const std::string param="()V";
jvm=jvm_;
JNIEnv * curEnv = getCurrentEnv();
localClass = curEnv->FindClass( this->className().c_str() ) ;
if (localClass == NULL) {
throw GiwsException::JniClassNotFoundException(curEnv, this->className());
}
this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
/* localClass is not needed anymore */
curEnv->DeleteLocalRef(localClass);
if (this->instanceClass == NULL) {
throw GiwsException::JniObjectCreationException(curEnv, this->className());
}
constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
if(constructObject == NULL){
throw GiwsException::JniObjectCreationException(curEnv, this->className());
}
localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
if(localInstance == NULL){
throw GiwsException::JniObjectCreationException(curEnv, this->className());
}
this->instance = curEnv->NewGlobalRef(localInstance) ;
if(this->instance == NULL){
throw GiwsException::JniObjectCreationException(curEnv, this->className());
}
/* localInstance not needed anymore */
curEnv->DeleteLocalRef(localInstance);
/* Methods ID set to NULL */
jobjectArray_getAllListenedVariablesID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID=NULL;
voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID=NULL;
voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID=NULL;
voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID=NULL;
voidcloseListjintArray_intintjintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID=NULL;
voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjintintID=NULL;
}
void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int row, int col, int nbItem, int const* nbItemRow, int nbItemRowSize, int const* colPos, int colPosSize, double const* real, int realSize, double const* imag, int imagSize, int handlerId){
JNIEnv * curEnv = NULL;
jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
jclass cls = curEnv->FindClass( className().c_str() );
jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[IIII[I[I[D[DI)V" ) ;
if (voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID == NULL) {
throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
}
jstring varName_ = curEnv->NewStringUTF( varName );
if (varName != NULL && varName_ == NULL)
{
throw GiwsException::JniBadAllocException(curEnv);
}
jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
if (indexes_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
jintArray nbItemRow_ = curEnv->NewIntArray( nbItemRowSize ) ;
if (nbItemRow_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetIntArrayRegion( nbItemRow_, 0, nbItemRowSize, (jint*)(nbItemRow) ) ;
jintArray colPos_ = curEnv->NewIntArray( colPosSize ) ;
if (colPos_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetIntArrayRegion( colPos_, 0, colPosSize, (jint*)(colPos) ) ;
jdoubleArray real_ = curEnv->NewDoubleArray( realSize ) ;
if (real_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetDoubleArrayRegion( real_, 0, realSize, (jdouble*)(real) ) ;
jdoubleArray imag_ = curEnv->NewDoubleArray( imagSize ) ;
if (imag_ == NULL)
{
// check that allocation succeed
throw GiwsException::JniBadAllocException(curEnv);
}
curEnv->SetDoubleArrayRegion( imag_, 0, imagSize, (jdouble*)(imag) ) ;
curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID ,varName_, indexes_, row, col, nbItem, nbItemRow_, colPos_, real_, imag_, handlerId);
curEnv->DeleteLocalRef(varName_);
curEnv->DeleteLocalRef(indexes_);
curEnv->DeleteLocalRef(nbItemRow_);
curEnv->DeleteLocalRef(colPos_);
curEnv->DeleteLocalRef(real_);
curEnv->DeleteLocalRef(imag_);
curEnv->DeleteLocalRef(cls);
if (curEnv->ExceptionCheck()) {
throw GiwsException::JniCallMethodException(curEnv);
}
}
//-------------------------------------------
//-------------------------------------------
void TextEntryJavaInterface::SetCapitalisationMethod(CSInput::TextEntry::Capitalisation ineKeyboardCapitalisation)
{
JNIEnv* pEnv = JavaInterfaceManager::GetSingletonPtr()->GetJNIEnvironmentPtr();
s32 dwKeyboardCapitalisation = KeyboardCapitalisationToInteger(ineKeyboardCapitalisation);
pEnv->CallVoidMethod(GetJavaObject(), GetMethodID("setCapitalisationMethod"), dwKeyboardCapitalisation);
}
//-------------------------------------------
//-------------------------------------------
void TextEntryJavaInterface::SetKeyboardType(CSInput::TextEntry::Type ineKeyboardType)
{
JNIEnv* pEnv = JavaInterfaceManager::GetSingletonPtr()->GetJNIEnvironmentPtr();
s32 dwKeyboardType = KeyboardTypeToInteger(ineKeyboardType);
pEnv->CallVoidMethod(GetJavaObject(), GetMethodID("setKeyboardType"), dwKeyboardType);
}
//-----------------------------------------------
//-----------------------------------------------
void TextEntryJavaInterface::Deactivate()
{
JNIEnv* pEnv = JavaInterfaceManager::GetSingletonPtr()->GetJNIEnvironmentPtr();
pEnv->CallVoidMethod(GetJavaObject(), GetMethodID("deactivate"));
}