/**
* @brief Inicializa a JVM; Aloca memória para as estruturas principais;
Chama o carregador para a primeira classe; inicializa a primeira classe
*
* @param classHeap
* @param objectHeap
* @param stackFrame
* @param classPathF_ptr
*/
void jvmStartup(ClassFile *classHeap_ptr, Object *objectHeap_ptr, Frame *stackFrame_ptr, FILE *classPathF_ptr, dataMSize_t *dmSize_ptr){
classHeap_ptr = malloc( CLSHEAP_MAX*sizeof( ClassFile ) );
objectHeap_ptr = malloc( OBJHEAP_MAX*sizeof( Object_t ) );
stackFrame_ptr = malloc( STKFRAME_MAX*sizeof( Frame ) );
dmSize_ptr->clsHeap_size = 0;
dmSize_ptr->objHeap_size = 0;
dmSize_ptr->stkHeap_size = 0;
//Carrega a classe inicial
//OK!
loadClass(classPathF_ptr, classHeap_ptr, dmSize_ptr);
printf("\nstatic_values_size %d", classHeap_ptr->static_values_size);
for(int i = 0; i < classHeap_ptr->static_values_size; i++)
printf("\nname %s", classHeap_ptr->static_values[i].field_name);
//Checa a consistência da classe
printf("\n\nConteudo do .class");
printf("\n--------------------------------");
print_ClassFile(classHeap_ptr);
//Inicializa a classe inicial, roda clinit
//OK!
initializeClass(classHeap_ptr, stackFrame_ptr, dmSize_ptr, classHeap_ptr);
//initializeClass(classHeap_ptr, stackFrame_ptr, &dmSize_ptr->stkHeap_size); //Sei que o primeiro elemento da classHeap é a classe inicial
//Chamo o método main
callMethod(classHeap_ptr, stackFrame_ptr, dmSize_ptr, classHeap_ptr, "main", "([Ljava/lang/String;)V");
}
/*Create a new String
*invoked by:OPC_LDC
*/
O createJstring(char *s)
{
if (java_lang_String == NULL)
java_lang_String = loadClass("java/lang/String");
ClassBlock_t *cb = CLASS_CB(java_lang_String);
if (!inited)
initString();
O char_obj, string_obj;
FieldBlock_t *fb;
int length, offset;
length = strlen(s);
char_obj = char2Char(s);
short *data = (short *) char_obj->data;
unsigned char *ss = (unsigned char *) s;
convertUtf8(ss, data);
string_obj = allocObject(java_lang_String);
string_obj->type = OBJECT_STRING;
OBJECT_DATA(string_obj, value_offset - 1, O) = char_obj;
OBJECT_DATA(string_obj, count_offset - 1, int) = length;
//*(((Object**)string_obj->data)+offset-1) = char_obj;
string_obj->cb = cb;
string_obj->el_size = sizeof(int);
return string_obj;
}
/*
void mainInit(char* className, Interpretador* interpretador, int paramsNumber, char** cmdLineParams) {
char* methodName = "main", methodDescriptor = "([Ljava/lang/String;)V";
ClassFile* cFile = loadClass(interpretador, className);
pushFrame(&(interpretador->topStackFrame));
frameInit(interpretador->initClass, *cFile, interpretador->topStackFrame, methodName, methodDescriptor);
}
*/
void methodInit(char* className, char* methodName, char* methodDescriptor, Interpretador* interpretador, int paramsNumber, int print) {
int i;
ClassFile* cFile = loadClass(interpretador, className);
printf("FEZ LOAD\n");
if (print)
printClass(cFile, className);
pushFrame(&(interpretador->topStackFrame));
printf("\n\nPUSHOUFRAME\n");
frameInit(interpretador->initClass, *cFile, interpretador->topStackFrame, methodName, methodDescriptor);
printf("\n\nINITIOUFRAME\n");
if (interpretador->topStackFrame->nextFrame != NULL) {
/*if (interpretador->topStackFrame->nextFrame != NULL) {*/
for (i = countSlots(interpretador->topStackFrame->nextFrame->frame->topOperand, paramsNumber) - 1; i >= 0; i--) {
if (interpretador->topStackFrame->nextFrame->frame->topOperand->operand.type32_64 == CAT2)
i--;
interpretador->topStackFrame->frame->localVarArray[i] = (int)&(interpretador->topStackFrame->nextFrame->frame->topOperand);
}
}
printf("\n\nSAIU DA METHOD INIT\n");
/*}*/
}
void CompileContext::loadBaseAndInterfaces(ASTClass* pclass)
{
if ( pclass->hasBaseType() )
{
loadClass(pclass->getBaseType().getObjectName());
pclass->setBaseClass(resolveClass(pclass->getBaseType().getObjectName()));
}
ASTTypeList& intrfaces = pclass->getInterfaces();
for ( int index = 0; index < intrfaces.size(); index++ )
{
ASTType& type = intrfaces[index];
loadClass(type.getObjectName());
type.setObjectClass(resolveClass(type.getObjectName()));
}
}
/**
* Returns the class matching the given class name
* loading the class into memory if necessary.
*/
Class* ClassLoader::findClass( const char* classname ) {
// if the class is already loaded ...
if( classes.count( classname ) ) {
return classes[classname];
}
// create the file name
char *filename = new char[ strlen( classname ) + 5 ];
sprintf( filename, "%s.scc", classname );
// otherwise, load the class
return loadClass( filename );
}
CArtifact * CArtHandler::loadFromJson(const JsonNode & node, const std::string & identifier)
{
CArtifact * art;
if (!VLC->modh->modules.COMMANDERS || node["growing"].isNull())
art = new CArtifact();
else
{
auto growing = new CGrowingArtifact();
loadGrowingArt(growing, node);
art = growing;
}
art->identifier = identifier;
const JsonNode & text = node["text"];
art->name = text["name"].String();
art->description = text["description"].String();
art->eventText = text["event"].String();
const JsonNode & graphics = node["graphics"];
art->image = graphics["image"].String();
if (!graphics["large"].isNull())
art->large = graphics["large"].String();
else
art->large = art->image;
art->advMapDef = graphics["map"].String();
art->price = node["value"].Float();
loadSlots(art, node);
loadClass(art, node);
loadType(art, node);
loadComponents(art, node);
for (auto b : node["bonuses"].Vector())
{
auto bonus = JsonUtils::parseBonus(b);
art->addNewBonus(bonus);
}
return art;
}
void initString()
{
if (java_lang_String == NULL)
java_lang_String = loadClass("java/lang/String");
FieldBlock_t *count;
FieldBlock_t *value;
FieldBlock_t *offset;
count = (FieldBlock_t *) findField(java_lang_String, "count", "I");
value = (FieldBlock_t *) findField(java_lang_String, "value", "[C");
offset = (FieldBlock_t *) findField(java_lang_String, "offset", "I");
if ((count == NULL) || (value == NULL) || (offset == NULL))
throwException("initString error");
count_offset = count->offset;
value_offset = value->offset;
offset_offset = offset->offset;
inited = TRUE;
}
static Class* loadUserClass(Env* env, const char* className, ClassLoader* classLoader) {
return loadClass(env, className, classLoader, _bcClassesHash);
}
JNIEnv* CBarcode1::jniInit(JNIEnv* env)
{
static bool initialized = false;
env = MethodExecutorJni::jniInit(env);
if (!env) {
RAWLOG_ERROR("JNI init failed");
return 0;
}
if(!initialized)
{
//init Barcode1FactorySingleton JNI
s_clsFactorySingleton = loadClass(env, FACTORY_SINGLETON_CLASS);
if (!s_clsFactorySingleton) return 0;
s_midFactorySetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "setInstance", "(Lcom/motorolasolutions/rhoelements/barcode1/IBarcode1Factory;)V");
if(!s_midFactorySetInstance)
{
RAWLOG_ERROR1("Failed to get method 'setInstance' for java class %s", FACTORY_SINGLETON_CLASS);
return NULL;
}
s_midFactoryGetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "getInstance", "()Lcom/motorolasolutions/rhoelements/barcode1/IBarcode1Factory;");
if(!s_midFactoryGetInstance)
{
RAWLOG_ERROR1("Failed to get method 'getInstance' for java class %s", FACTORY_SINGLETON_CLASS);
return NULL;
}
//init IBarcode1Factory JNI
s_clsIFactory = loadClass(env, IFACTORY_CLASS);
if (!s_clsIFactory) return 0;
s_midGetApiSingleton = env->GetMethodID(s_clsIFactory, "getApiSingleton", "()Lcom/motorolasolutions/rhoelements/barcode1/IBarcode1Singleton;");
if(!s_midGetApiSingleton)
{
RAWLOG_ERROR1("Failed to get method 'getApiSingleton' for java class %s", IFACTORY_CLASS);
return NULL;
}
s_midGetApiObject = env->GetMethodID(s_clsIFactory, "getApiObject", "(Ljava/lang/String;)Lcom/motorolasolutions/rhoelements/barcode1/IBarcode1;");
if(!s_midGetApiObject)
{
RAWLOG_ERROR1("Failed to get method 'getApiObject' for java class %s", IFACTORY_CLASS);
return NULL;
}
// s_clsSingletonBase = loadClass(env, SINGLETON_BASE_CLASS);
// if (!s_clsSingletonBase) return 0;
s_clsObjectBase = loadClass(env, OBJECT_BASE_CLASS);
if (!s_clsObjectBase) return 0;
s_clsGetPropsTask = loadClass(env, GETPROPS_TASK_CLASS);
if (!s_clsGetPropsTask) return 0;
s_clsGetProps1Task = loadClass(env, GETPROPS1_TASK_CLASS);
if (!s_clsGetProps1Task) return 0;
s_clsGetProps2Task = loadClass(env, GETPROPS2_TASK_CLASS);
if (!s_clsGetProps2Task) return 0;
s_clsTakeBarcodeTask = loadClass(env, TAKEBARCODE_TASK_CLASS);
if (!s_clsTakeBarcodeTask) return 0;
s_midGetPropsTask = env->GetMethodID(s_clsGetPropsTask, "<init>",
"(Lcom/motorolasolutions/rhoelements/barcode1/IBarcode1;Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midGetPropsTask)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", GETPROPS_TASK_CLASS);
return NULL;
}
s_midGetProps1Task = env->GetMethodID(s_clsGetProps1Task, "<init>",
"(Lcom/motorolasolutions/rhoelements/barcode1/IBarcode1;Ljava/lang/String;Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midGetProps1Task)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", GETPROPS1_TASK_CLASS);
return NULL;
}
s_midGetProps2Task = env->GetMethodID(s_clsGetProps2Task, "<init>",
"(Lcom/motorolasolutions/rhoelements/barcode1/IBarcode1;Ljava/util/List;Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midGetProps2Task)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", GETPROPS2_TASK_CLASS);
return NULL;
}
s_clsISingleton = loadClass(env, ISINGLETON_CLASS);
if (!s_clsISingleton) return 0;
s_midEnumerate = env->GetMethodID(s_clsISingleton, "enumerate", "(Lcom/motorolasolutions/rhoelements/IMethodResult;)V");
if(!s_midEnumerate)
{
RAWLOG_ERROR1("Failed to get method 'enumerate' for java class %s", ISINGLETON_CLASS);
return NULL;
}
s_midGetDefaultID = env->GetMethodID(s_clsISingleton, "getDefaultID", "()Ljava/lang/String;");
if(!s_midGetDefaultID)
{
RAWLOG_ERROR1("Failed to get method 'getDefaultID' for java class %s", ISINGLETON_CLASS);
return NULL;
}
s_midSetDefaultID = env->GetMethodID(s_clsISingleton, "setDefaultID", "(Ljava/lang/String;)V");
if(!s_midSetDefaultID)
{
RAWLOG_ERROR1("Failed to get method 'setDefaultID' for java class %s", ISINGLETON_CLASS);
return NULL;
}
initialized = true;
RAWTRACE("CBarcode1 JNI init succeeded");
}
return env;
}
JNIEnv* CLightsensorBase::jniInit(JNIEnv* env)
{
static bool initialized = false;
env = MethodExecutorJni::jniInit(env);
if (!env) {
LOG(FATAL) + "JNI init failed";
return 0;
}
if(!initialized)
{
//init LightsensorFactorySingleton JNI
s_clsFactorySingleton = loadClass(env, FACTORY_SINGLETON_CLASS);
if (!s_clsFactorySingleton) return 0;
s_midFactorySetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "setInstance", "(Lcom/rho/lightsensor/ILightsensorFactory;)V");
if(!s_midFactorySetInstance)
{
LOG(FATAL) + "Failed to get method 'setInstance' for java class " + FACTORY_SINGLETON_CLASS;
return NULL;
}
s_midFactoryGetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "getInstance", "()Lcom/rho/lightsensor/ILightsensorFactory;");
if(!s_midFactoryGetInstance)
{
LOG(FATAL) + "Failed to get method 'getInstance' for java class " + FACTORY_SINGLETON_CLASS;
return NULL;
}
//init ILightsensorFactory JNI
s_clsIFactory = loadClass(env, IFACTORY_CLASS);
if (!s_clsIFactory) return 0;
s_midGetApiSingleton = env->GetMethodID(s_clsIFactory, "getApiSingleton", "()Lcom/rho/lightsensor/ILightsensorSingleton;");
if(!s_midGetApiSingleton)
{
LOG(FATAL) + "Failed to get method 'getApiSingleton' for java class " + IFACTORY_CLASS;
return NULL;
}
s_midGetApiObject = env->GetMethodID(s_clsIFactory, "getApiObject", "(Ljava/lang/String;)Lcom/rho/lightsensor/ILightsensor;");
if(!s_midGetApiObject)
{
LOG(FATAL) + "Failed to get method 'getApiObject' for java class " + IFACTORY_CLASS;
return NULL;
}
s_clsSingletonBase = loadClass(env, SINGLETON_BASE_CLASS);
if (!s_clsSingletonBase) return 0;
s_clsObjectBase = loadClass(env, OBJECT_BASE_CLASS);
if (!s_clsObjectBase) return 0;
s_clsgetDelayTask = loadClass(env, GETDELAY_TASK_CLASS);
if (!s_clsgetDelayTask) return 0;
s_midgetDelayTask = env->GetMethodID(s_clsgetDelayTask, "<init>",
"(Lcom/rho/lightsensor/ILightsensor;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetDelayTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETDELAY_TASK_CLASS;
return NULL;
}
s_clssetDelayTask = loadClass(env, SETDELAY_TASK_CLASS);
if (!s_clssetDelayTask) return 0;
s_midsetDelayTask = env->GetMethodID(s_clssetDelayTask, "<init>",
"(Lcom/rho/lightsensor/ILightsensor;ILcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midsetDelayTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + SETDELAY_TASK_CLASS;
return NULL;
}
s_clsenumerateTask = loadClass(env, ENUMERATE_TASK_CLASS);
if (!s_clsenumerateTask) return 0;
s_midenumerateTask = env->GetMethodID(s_clsenumerateTask, "<init>",
"(Lcom/rho/lightsensor/ILightsensorSingleton;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midenumerateTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + ENUMERATE_TASK_CLASS;
return NULL;
}
s_clsstartListeningTask = loadClass(env, STARTLISTENING_TASK_CLASS);
if (!s_clsstartListeningTask) return 0;
s_midstartListeningTask = env->GetMethodID(s_clsstartListeningTask, "<init>",
"(Lcom/rho/lightsensor/ILightsensor;Ljava/util/Map;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midstartListeningTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + STARTLISTENING_TASK_CLASS;
return NULL;
}
s_clsstopListeningTask = loadClass(env, STOPLISTENING_TASK_CLASS);
if (!s_clsstopListeningTask) return 0;
s_midstopListeningTask = env->GetMethodID(s_clsstopListeningTask, "<init>",
"(Lcom/rho/lightsensor/ILightsensor;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midstopListeningTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + STOPLISTENING_TASK_CLASS;
return NULL;
}
s_clsIDefaultId = loadClass(env, IDEFAULTID_CLASS);
if (!s_clsIDefaultId) return 0;
s_midGetDefaultID = env->GetMethodID(s_clsIDefaultId, "getDefaultID", "()Ljava/lang/String;");
if(!s_midGetDefaultID)
{
LOG(FATAL) + "Failed to get method 'getDefaultID' for java class " + IDEFAULTID_CLASS;
return NULL;
}
s_midSetDefaultID = env->GetMethodID(s_clsIDefaultId, "setDefaultID", "(Ljava/lang/String;)V");
if(!s_midSetDefaultID)
{
LOG(FATAL) + "Failed to get method 'setDefaultID' for java class " + IDEFAULTID_CLASS;
return NULL;
}
initialized = true;
LOG(TRACE) + "CLightsensor JNI init succeeded";
}
return env;
}
static Class* loadBootClass(Env* env, const char* className, Object* classLoader) {
return loadClass(env, className, classLoader, _bcBootClassesHash);
}
/*
* Function that is called by the sections walker
*/
static int feedbackWalker(void *arg,
struct section_file *sf,
struct section_file_data *sfd)
{
int retval = 1;
/* Check for library section */
if( sfd->sfd_type == &lib_section )
{
struct lib_section_data *lsd = (struct lib_section_data *)sfd;
if( lsd->lsd_flags & LSDF_PRELOAD )
loadNativeLibrary2(sfd->sfd_name, 0, 0, 0);
}
/* Check for jit-code section */
else if( sfd->sfd_type == &jit_section )
{
#if defined(TRANSLATOR)
struct jit_section_data *jsd = (struct jit_section_data *)sfd;
if( jsd->jsd_flags & JSDF_PRECOMPILE )
{
int len, lpc, sig_start = -1, meth_start = -1;
Utf8Const *u8cname, *u8mname, *u8sig;
Hjava_lang_Class *cls;
char *full_name;
/*
* Parse the name of the section to get the class,
* method, and signature
*/
full_name = sfd->sfd_name;
len = strlen(full_name);
for( lpc = len - 1;
(lpc >= 0) && (meth_start < 0);
lpc-- )
{
switch( full_name[lpc] )
{
case '(':
sig_start = lpc;
break;
case '/':
if( sig_start > 0 )
meth_start = lpc + 1;
break;
}
}
if( (sig_start > 0) && (meth_start > 0) )
{
jobject loader = 0;
errorInfo info;
/* Get the right strings and find the class */
u8cname = utf8ConstNew(full_name,
meth_start - 1);
u8mname = utf8ConstNew(&full_name[meth_start],
sig_start - meth_start);
u8sig = utf8ConstNew(&full_name[sig_start],
len - sig_start);
if( u8cname && u8mname && u8sig &&
(cls = loadClass(u8cname, loader, &info)) )
{
Method *meth;
if( (meth = findMethodLocal(cls,
u8mname,
u8sig)) &&
!(meth->accflags & ACC_NATIVE) )
{
if( translate(meth, &info) )
{
}
else
{
dprintf(
"Feedback: "
" Precompile "
"failed for "
"%s!\n",
full_name);
}
}
else if( !meth )
{
dprintf(
"Feedback: Didn't "
"find method"
" %s\n",
full_name);
}
}
else
{
dprintf(
"Feedback: Couldn't load "
"class %s\n",
u8cname->data);
}
utf8ConstRelease(u8cname);
utf8ConstRelease(u8mname);
utf8ConstRelease(u8sig);
}
else
{
dprintf(
"Feedback: Malformed method `%s'\n",
full_name);
}
}
#else
{
static int precompile_msg = 0;
if( !precompile_msg )
{
precompile_msg = 1;
dprintf(
"Feedback: Cannot precompile java for "
"the interpreter\n");
}
}
#endif
}
return( retval );
}
/*
* Convert string name to class object.
*/
struct Hjava_lang_Class*
java_lang_VMClass_forName0(struct Hjava_lang_String* str, struct Hjava_lang_ClassLoader* loader)
{
errorInfo einfo;
Hjava_lang_Class* clazz;
Utf8Const *utf8buf;
const char *buf;
int jlen;
jchar *js;
/*
* NB: internally, we store class names as path names (with slashes
* instead of dots. However, we must also prevent calls to
* "java/lang/Object" or "[[Ljava/lang/Object;" from succeeding.
* Since class names cannot have slashes, we reject all attempts
* to look up names that do. Awkward. Inefficient.
*/
js = STRING_DATA(str);
jlen = STRING_SIZE(str);
while (--jlen > 0) {
if (*js++ == '/') {
postExceptionMessage(&einfo,
JAVA_LANG(ClassNotFoundException),
"Cannot have slashes - use dots instead.");
throwError(&einfo);
}
}
/*
* Note the following oddity:
*
* It is apparently perfectly legal to call forName for array types,
* such as "[Ljava.lang.String;" or "[B".
* However, it is wrong to call Class.forName("Ljava.lang.String;")
*
* This situation is similar to the constant pool resolution. We
* therefore do the same thing as in getClass in kaffevm/lookup.c,
* that is, use either loadArray or loadClass depending on the name.
*
* This is somewhat described in Section 5.1.3 of the VM
* Specification, titled "Array Classes". This section seems to
* imply that we must avoid asking a class loader to resolve such
* array names (those starting with an [), and this is what calling
* loadArray does.
*/
/* Convert string to utf8, converting '.' to '/' */
utf8buf = checkPtr(stringJava2Utf8ConstReplace(str, '.', '/'));
buf = utf8buf->data;
if (buf[0] == '[') {
clazz = loadArray(utf8buf, loader, &einfo);
}
else {
clazz = loadClass(utf8buf, loader, &einfo);
}
/* if an error occurred, throw an exception */
if (clazz == 0) {
utf8ConstRelease(utf8buf);
throwError(&einfo);
}
utf8ConstRelease(utf8buf);
/*
* loadClass returns the class in state CSTATE_LINKED.
*
* Processing to CSTATE_COMPLETE will initialize the class, resolve
* its constants and run its static initializers.
*
* The option to load a class via forName without initializing it
* was introduced in 1.2, presumably for the convenience of
* programs such as stub compilers.
*/
if (processClass(clazz, CSTATE_COMPLETE, &einfo) == false) {
throwError(&einfo);
}
return (clazz);
}
JNIEnv* CGenPropBagBase::jniInit(JNIEnv* env)
{
static bool initialized = false;
env = MethodExecutorJni::jniInit(env);
if (!env) {
LOG(FATAL) + "JNI init failed";
return 0;
}
if(!initialized)
{
//init GenPropBagFactorySingleton JNI
s_clsFactorySingleton = loadClass(env, FACTORY_SINGLETON_CLASS);
if (!s_clsFactorySingleton) return 0;
s_midFactorySetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "setInstance", "(Lcom/rho/genpropbag/IGenPropBagFactory;)V");
if(!s_midFactorySetInstance)
{
LOG(FATAL) + "Failed to get method 'setInstance' for java class " + FACTORY_SINGLETON_CLASS;
return NULL;
}
s_midFactoryGetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "getInstance", "()Lcom/rho/genpropbag/IGenPropBagFactory;");
if(!s_midFactoryGetInstance)
{
LOG(FATAL) + "Failed to get method 'getInstance' for java class " + FACTORY_SINGLETON_CLASS;
return NULL;
}
//init IGenPropBagFactory JNI
s_clsIFactory = loadClass(env, IFACTORY_CLASS);
if (!s_clsIFactory) return 0;
s_midGetApiSingleton = env->GetMethodID(s_clsIFactory, "getApiSingleton", "()Lcom/rho/genpropbag/IGenPropBagSingleton;");
if(!s_midGetApiSingleton)
{
LOG(FATAL) + "Failed to get method 'getApiSingleton' for java class " + IFACTORY_CLASS;
return NULL;
}
s_midGetApiObject = env->GetMethodID(s_clsIFactory, "getApiObject", "(Ljava/lang/String;)Lcom/rho/genpropbag/IGenPropBag;");
if(!s_midGetApiObject)
{
LOG(FATAL) + "Failed to get method 'getApiObject' for java class " + IFACTORY_CLASS;
return NULL;
}
s_clsSingletonBase = loadClass(env, SINGLETON_BASE_CLASS);
if (!s_clsSingletonBase) return 0;
s_clsObjectBase = loadClass(env, OBJECT_BASE_CLASS);
if (!s_clsObjectBase) return 0;
s_clsgetBoolPropTask = loadClass(env, GETBOOLPROP_TASK_CLASS);
if (!s_clsgetBoolPropTask) return 0;
s_midgetBoolPropTask = env->GetMethodID(s_clsgetBoolPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetBoolPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETBOOLPROP_TASK_CLASS;
return NULL;
}
s_clssetBoolPropTask = loadClass(env, SETBOOLPROP_TASK_CLASS);
if (!s_clssetBoolPropTask) return 0;
s_midsetBoolPropTask = env->GetMethodID(s_clssetBoolPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;ZLcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midsetBoolPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + SETBOOLPROP_TASK_CLASS;
return NULL;
}
s_clsgetIntPropTask = loadClass(env, GETINTPROP_TASK_CLASS);
if (!s_clsgetIntPropTask) return 0;
s_midgetIntPropTask = env->GetMethodID(s_clsgetIntPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetIntPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETINTPROP_TASK_CLASS;
return NULL;
}
s_clssetIntPropTask = loadClass(env, SETINTPROP_TASK_CLASS);
if (!s_clssetIntPropTask) return 0;
s_midsetIntPropTask = env->GetMethodID(s_clssetIntPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;ILcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midsetIntPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + SETINTPROP_TASK_CLASS;
return NULL;
}
s_clsgetFloatPropTask = loadClass(env, GETFLOATPROP_TASK_CLASS);
if (!s_clsgetFloatPropTask) return 0;
s_midgetFloatPropTask = env->GetMethodID(s_clsgetFloatPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetFloatPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETFLOATPROP_TASK_CLASS;
return NULL;
}
s_clssetFloatPropTask = loadClass(env, SETFLOATPROP_TASK_CLASS);
if (!s_clssetFloatPropTask) return 0;
s_midsetFloatPropTask = env->GetMethodID(s_clssetFloatPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;DLcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midsetFloatPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + SETFLOATPROP_TASK_CLASS;
return NULL;
}
s_clsgetStringPropTask = loadClass(env, GETSTRINGPROP_TASK_CLASS);
if (!s_clsgetStringPropTask) return 0;
s_midgetStringPropTask = env->GetMethodID(s_clsgetStringPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetStringPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETSTRINGPROP_TASK_CLASS;
return NULL;
}
s_clssetStringPropTask = loadClass(env, SETSTRINGPROP_TASK_CLASS);
if (!s_clssetStringPropTask) return 0;
s_midsetStringPropTask = env->GetMethodID(s_clssetStringPropTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Ljava/lang/String;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midsetStringPropTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + SETSTRINGPROP_TASK_CLASS;
return NULL;
}
s_clsenumerateTask = loadClass(env, ENUMERATE_TASK_CLASS);
if (!s_clsenumerateTask) return 0;
s_midenumerateTask = env->GetMethodID(s_clsenumerateTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBagSingleton;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midenumerateTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + ENUMERATE_TASK_CLASS;
return NULL;
}
s_clsgetPropertyTask = loadClass(env, GETPROPERTY_TASK_CLASS);
if (!s_clsgetPropertyTask) return 0;
s_midgetPropertyTask = env->GetMethodID(s_clsgetPropertyTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Ljava/lang/String;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetPropertyTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETPROPERTY_TASK_CLASS;
return NULL;
}
s_clsgetPropertiesTask = loadClass(env, GETPROPERTIES_TASK_CLASS);
if (!s_clsgetPropertiesTask) return 0;
s_midgetPropertiesTask = env->GetMethodID(s_clsgetPropertiesTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Ljava/util/List;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetPropertiesTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETPROPERTIES_TASK_CLASS;
return NULL;
}
s_clsgetAllPropertiesTask = loadClass(env, GETALLPROPERTIES_TASK_CLASS);
if (!s_clsgetAllPropertiesTask) return 0;
s_midgetAllPropertiesTask = env->GetMethodID(s_clsgetAllPropertiesTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midgetAllPropertiesTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + GETALLPROPERTIES_TASK_CLASS;
return NULL;
}
s_clssetPropertyTask = loadClass(env, SETPROPERTY_TASK_CLASS);
if (!s_clssetPropertyTask) return 0;
s_midsetPropertyTask = env->GetMethodID(s_clssetPropertyTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Ljava/lang/String;Ljava/lang/String;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midsetPropertyTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + SETPROPERTY_TASK_CLASS;
return NULL;
}
s_clssetPropertiesTask = loadClass(env, SETPROPERTIES_TASK_CLASS);
if (!s_clssetPropertiesTask) return 0;
s_midsetPropertiesTask = env->GetMethodID(s_clssetPropertiesTask, "<init>",
"(Lcom/rho/genpropbag/IGenPropBag;Ljava/util/Map;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
if(!s_midsetPropertiesTask)
{
LOG(FATAL) + "Failed to get constructor for java class " + SETPROPERTIES_TASK_CLASS;
return NULL;
}
s_clsIDefaultId = loadClass(env, IDEFAULTID_CLASS);
if (!s_clsIDefaultId) return 0;
s_midGetDefaultID = env->GetMethodID(s_clsIDefaultId, "getDefaultID", "()Ljava/lang/String;");
if(!s_midGetDefaultID)
{
LOG(FATAL) + "Failed to get method 'getDefaultID' for java class " + IDEFAULTID_CLASS;
return NULL;
}
s_midSetDefaultID = env->GetMethodID(s_clsIDefaultId, "setDefaultID", "(Ljava/lang/String;)V");
if(!s_midSetDefaultID)
{
LOG(FATAL) + "Failed to get method 'setDefaultID' for java class " + IDEFAULTID_CLASS;
return NULL;
}
initialized = true;
LOG(TRACE) + "CGenPropBag JNI init succeeded";
}
return env;
}
