Пример #1
0
RHO_GLOBAL VALUE get_camera_info(const char* camera_type) {
    
    JNIEnv *env = jnienv();
    jclass cls = getJNIClass(RHODES_JAVA_CLASS_CAMERA);
    if (!cls) return rho_ruby_get_NIL();
    jmethodID mid_w = getJNIClassStaticMethod(env, cls, "getMaxCameraWidth", "(Ljava/lang/String;)I");
    jmethodID mid_h = getJNIClassStaticMethod(env, cls, "getMaxCameraHeight", "(Ljava/lang/String;)I");
    if ((!mid_w) || (!mid_h)) return rho_ruby_get_NIL();
    int w = env->CallStaticIntMethod(cls, mid_w, rho_cast<jhstring>(camera_type).get());
    int h = env->CallStaticIntMethod(cls, mid_h, rho_cast<jhstring>(camera_type).get());
    
    if ((w <= 0) || (h <= 0)) {
        return rho_ruby_get_NIL();
    }

    VALUE hash = rho_ruby_createHash();
    
    VALUE hash_max_resolution = rho_ruby_createHash();
    
    rho_ruby_add_to_hash(hash_max_resolution, rho_ruby_create_string("width"), rho_ruby_create_integer(w));
    rho_ruby_add_to_hash(hash_max_resolution, rho_ruby_create_string("height"), rho_ruby_create_integer(h));

    rho_ruby_add_to_hash(hash, rho_ruby_create_string("max_resolution"), hash_max_resolution);
    
    return hash;
}
Пример #2
0
VALUE getallPhonebookRecords(void* pb) {
#if defined (_WIN32_WCE)//&& !defined( OS_PLATFORM_MOTCE )
	if (RHO_IS_WMDEVICE && pb) {
		CNativeAddressBook* phonebook = (CNativeAddressBook*)pb;
        VALUE valGc = rho_ruby_disable_gc();
        CHoldRubyValue hash(rho_ruby_createHash());
		
		std::vector<CABRecord*> records;
		phonebook->getAllRecords(records);
		while(records.size() > 0) {
			CABRecord* record = records.back();
			const char* rid = record->getValue("id").c_str();
			if (rid) {
				LOGC(TRACE,"Phonebook") + "Adding record " + rid;
				addHashToHash(hash,rid,_getRecord(record));
			}
			delete record;
			records.pop_back();
		}

        rho_ruby_enable_gc(valGc);
		return hash;
	}	
#endif
	return rho_ruby_get_NIL();	
}
Пример #3
0
VALUE rho_cast_helper<VALUE, jobject>::convertJavaMapToRubyHash(jobject objMap)
{
    jhobject objSet = m_env->CallObjectMethod(objMap, midMapKeySet);
    if(m_env->ExceptionCheck() == JNI_TRUE)
    {
        rho::String message = rho::common::clearException(m_env);
        RAWLOG_ERROR(message.c_str());
        return Qnil;
    }
    jhobject objIterator = m_env->CallObjectMethod(objSet.get(), midSetIterator);
    if(m_env->ExceptionCheck() == JNI_TRUE)
    {
        rho::String message = rho::common::clearException(m_env);
        RAWLOG_ERROR(message.c_str());
        return Qnil;
    }
                                  
    CHoldRubyValue retval(rho_ruby_createHash());
    while(m_env->CallBooleanMethod(objIterator.get(), midIteratorHasNext))
    {
        jhobject jhKey = m_env->CallObjectMethod(objIterator.get(), midIteratorNext);
        if (!jhKey) return Qnil;
        jhobject jhVal = m_env->CallObjectMethod(objMap, midMapGet, jhKey.get());
        if (!jhVal) return Qnil;

        CHoldRubyValue key(rho_cast<VALUE>(m_env, jhKey));
        CHoldRubyValue val(rho_cast<VALUE>(m_env, jhVal));

        rho_ruby_add_to_hash(retval, key, val);
    }
    return retval;
}
Пример #4
0
 VALUE rho_ringtone_manager_get_all()
 {
     //TODO: rho_ringtone_manager_get_all
     RAWLOGC_INFO("RingtoneManager", __FUNCTION__);
     CHoldRubyValue retval(rho_ruby_createHash());
     return retval;
 }
Пример #5
0
static VALUE createHashFromContact(jobject contactObj)
{
    if (logging_enable) RAWLOG_INFO("createHashFromContact() START");
    JNIEnv *env = jnienv();
    jclass contactCls = getJNIClass(RHODES_JAVA_CLASS_CONTACT);
    if (!contactCls) return Qnil;
    jclass fieldCls = getJNIClass(RHODES_JAVA_CLASS_CONTACT_FIELD);
    if (!fieldCls) return Qnil;

    jmethodID contactGetFieldMID = getJNIClassMethod(env, contactCls, "getField", "(I)Ljava/lang/String;");
    if (!contactGetFieldMID) return Qnil;

    CHoldRubyValue contactHash(rho_ruby_createHash());
    // contact.moveToBegin();

	int i;
	for (i = 0; i < PB_FIELDS_COUNT; i++) {
		jstring value = (jstring)env->CallObjectMethod(contactObj, contactGetFieldMID, i);
		if (value != NULL) {
			addStrToHash(contactHash, field_names[i], rho_cast<std::string>(value).c_str());
		}
		env->DeleteLocalRef(value);
	}
    if (logging_enable) RAWLOG_INFO("createHashFromContact() FINISH");
    return contactHash;
}
Пример #6
0
static VALUE _getRecord(CABRecord* record) {
	if (RHO_IS_WMDEVICE && record) {
        CHoldRubyValue hash(rho_ruby_createHash());
		record->enumValues(_addRecordValue,&(hash.m_value));
		return hash;
	}
	return rho_ruby_get_NIL();
}
Пример #7
0
	virtual unsigned long getObjectValue() {
        VALUE b_array = rho_ruby_create_array();
        VALUE b_hash = rho_ruby_createHash();
        rho_ruby_add_to_hash(b_hash, rho_ruby_create_string("friendlyName"), rho_ruby_create_string("RhoBarcode based on ZXing"));
        rho_ruby_add_to_hash(b_hash, rho_ruby_create_string("deviceName"), rho_ruby_create_string("RhoBarcode"));
        rho_ruby_add_to_array(b_array, b_hash);
        return b_array;
	}
Пример #8
0
VALUE convertJavaMapToRubyHash(jobject objMap)
{
    jclass clsMap = getJNIClass(RHODES_JAVA_CLASS_MAP);
    if (!clsMap) return Qnil;
    jclass clsSet = getJNIClass(RHODES_JAVA_CLASS_SET);
    if (!clsSet) return Qnil;
    jclass clsIterator = getJNIClass(RHODES_JAVA_CLASS_ITERATOR);
    if (!clsIterator) return Qnil;

    JNIEnv *env = jnienv();

    jmethodID midGet = getJNIClassMethod(env, clsMap, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
    if (!midGet) return Qnil;
    jmethodID midKeySet = getJNIClassMethod(env, clsMap, "keySet", "()Ljava/util/Set;");
    if (!midKeySet) return Qnil;
    jmethodID midIterator = getJNIClassMethod(env, clsSet, "iterator", "()Ljava/util/Iterator;");
    if (!midIterator) return Qnil;
    jmethodID midHasNext = getJNIClassMethod(env, clsIterator, "hasNext", "()Z");
    if (!midHasNext) return Qnil;
    jmethodID midNext = getJNIClassMethod(env, clsIterator, "next", "()Ljava/lang/Object;");
    if (!midNext) return Qnil;

    jobject objSet = env->CallObjectMethod(objMap, midKeySet);
    if (!objSet) return Qnil;
    jobject objIterator = env->CallObjectMethod(objSet, midIterator);
    if (!objIterator) return Qnil;
                                  
    CHoldRubyValue retval(rho_ruby_createHash());
    while(env->CallBooleanMethod(objIterator, midHasNext))
    {
        jstring objKey = (jstring)env->CallObjectMethod(objIterator, midNext);
        if (!objKey) return Qnil;
        jstring objValue = (jstring)env->CallObjectMethod(objMap, midGet, objKey);
        if (!objValue) return Qnil;

        std::string const &strKey = rho_cast<std::string>(objKey);
        std::string const &strValue = rho_cast<std::string>(objValue);
        addStrToHash(retval, strKey.c_str(), strValue.c_str());

        env->DeleteLocalRef(objKey);
        env->DeleteLocalRef(objValue);
    }
    return retval;
}
Пример #9
0
VALUE rho_ringtone_manager_get_all()
{
    LOG(INFO) + __FUNCTION__;
    
    CHoldRubyValue retval(rho_ruby_createHash());

#if _WIN32_WCE > 0x501

    Hashtable<String, String> ringtones;
    CRingtoneManager::getCRingtoneManager().getAllRingtones(ringtones);

    for (Hashtable<String, String>::iterator itr = ringtones.begin();
         itr != ringtones.end(); ++itr) {
        addStrToHash( retval, itr->first.c_str(), itr->second.c_str() );
    }
#endif
    
    return retval;
}
Пример #10
0
VALUE rho_cast_helper<VALUE, jobject>::convertJavaMapToRubyHash(JNIEnv *env, jobject objMap)
{
    jhobject objSet = env->CallObjectMethod(objMap, midMapKeySet);
    if (!objSet) return Qnil;
    jhobject objIterator = env->CallObjectMethod(objSet.get(), midSetIterator);
    if (!objIterator) return Qnil;
                                  
    CHoldRubyValue retval(rho_ruby_createHash());
    while(env->CallBooleanMethod(objIterator.get(), midIteratorHasNext))
    {
        jhstring objKey = (jstring)env->CallObjectMethod(objIterator.get(), midIteratorNext);
        if (!objKey) return Qnil;
        jhstring objValue = (jstring)env->CallObjectMethod(objMap, midMapGet, objKey.get());
        if (!objValue) return Qnil;

        std::string const &strKey = rho_cast<std::string>(objKey);
        std::string const &strValue = rho_cast<std::string>(objValue);
        addStrToHash(retval, strKey.c_str(), strValue.c_str());
    }
    return retval;
}
Пример #11
0
VALUE rho_cast_helper<VALUE, jobject>::convertJavaMapToRubyHash(jobject objMap)
{
    jhobject objSet = m_env->CallObjectMethod(objMap, midMapKeySet);
    if (!objSet) return Qnil;
    jhobject objIterator = m_env->CallObjectMethod(objSet.get(), midSetIterator);
    if (!objIterator) return Qnil;
                                  
    CHoldRubyValue retval(rho_ruby_createHash());
    while(m_env->CallBooleanMethod(objIterator.get(), midIteratorHasNext))
    {
        jhobject jhKey = m_env->CallObjectMethod(objIterator.get(), midIteratorNext);
        if (!jhKey) return Qnil;
        jhobject jhVal = m_env->CallObjectMethod(objMap, midMapGet, jhKey.get());
        if (!jhVal) return Qnil;

        CHoldRubyValue key(rho_cast<VALUE>(m_env, jhKey));
        CHoldRubyValue val(rho_cast<VALUE>(m_env, jhVal));

        rho_ruby_add_to_hash(retval, key, val);
    }
    return retval;
}
Пример #12
0
RHO_GLOBAL VALUE getallPhonebookRecords(void* pb)
{
    if (logging_enable) RAWLOG_INFO("getallPhonebookRecords() START");
    jobject phonebookObj = (jobject)pb;

    JNIEnv *env = jnienv();

    jclass phonebookCls = getJNIClass(RHODES_JAVA_CLASS_PHONEBOOK);
    if (!phonebookCls) return Qnil;
    jclass contactCls = getJNIClass(RHODES_JAVA_CLASS_CONTACT);
    if (!contactCls) return Qnil;

    jmethodID phonebookPrepareFullListMID = getJNIClassMethod(env, phonebookCls, "prepareFullList", "()V");
    if (!phonebookPrepareFullListMID) return Qnil;

    jmethodID phonebookMoveToBeginMID = getJNIClassMethod(env, phonebookCls, "moveToBegin", "()V");
    if (!phonebookMoveToBeginMID) return Qnil;
    jmethodID hasNextMID = getJNIClassMethod(env, phonebookCls, "hasNext", "()Z");
    if (!hasNextMID) return Qnil;
    jmethodID nextMID = getJNIClassMethod(env, phonebookCls, "next", "()Ljava/lang/Object;");
    if (!nextMID) return Qnil;
    jmethodID contactIdMID = getJNIClassMethod(env, contactCls, "id", "()Ljava/lang/String;");
    if (!contactIdMID) return Qnil;

	jmethodID contactGetFieldMID = getJNIClassMethod(env, contactCls, "getField", "(I)Ljava/lang/String;");
	if (!contactGetFieldMID) return Qnil;


    env->CallVoidMethod(phonebookObj, phonebookPrepareFullListMID);

    // pb.moveToBegin();
    env->CallVoidMethod(phonebookObj, phonebookMoveToBeginMID);


    VALUE valGc = rho_ruby_disable_gc();
    CHoldRubyValue hash(rho_ruby_createHash());
    // while(pb.hasNext())
    while(env->CallBooleanMethod(phonebookObj, hasNextMID))
    {
        // Contact contact = (Contact)pb.next();
        jobject contactObj = env->CallObjectMethod(phonebookObj, nextMID);
        if (!contactObj) return Qnil;
        // String id = contact.id();
        jstring idObj = (jstring)env->CallObjectMethod(contactObj, contactIdMID);
        if (!idObj) return Qnil;

        //addHashToHash(hash, rho_cast<std::string>(idObj).c_str(), createHashFromContact(contactObj));
		CHoldRubyValue contactHash(rho_ruby_createHash());
		// contact.moveToBegin();

		int i;
		for (i = 0; i < PB_FIELDS_COUNT; i++) {
			jstring value = (jstring)env->CallObjectMethod(contactObj, contactGetFieldMID, i);
			if (value != NULL) {
				addStrToHash(contactHash, field_names[i], rho_cast<std::string>(value).c_str());
				env->DeleteLocalRef(value);
			}
		}

		addHashToHash(hash, rho_cast<std::string>(idObj).c_str(), contactHash);

        env->DeleteLocalRef(idObj);
        env->DeleteLocalRef(contactObj);
    }

    rho_ruby_enable_gc(valGc);
    if (logging_enable) RAWLOG_INFO("getallPhonebookRecords() FINISH");
    return hash;
}
Пример #13
0
static VALUE 
_CreateRequestHash(HttpContextRef context, RouteRef route) {
	RAWTRACE("Creating Req Hash");
	
	VALUE hash = rho_ruby_createHash();
    rho_ruby_holdValue(hash);

	const char* applicationName = route->_application;
	addStrToHash(hash, "application", applicationName, strlen(applicationName));

	const char* modelName = route->_model;
	addStrToHash(hash, "model", modelName, strlen(modelName));

	if (route->_action!=NULL) {
		const char* actionName = route->_action;
		addStrToHash(hash, "action", actionName, strlen(actionName));
	}
	
	if (route->_id!=NULL) {
		const char* _id = route->_id;
		addStrToHash(hash, "id", _id, strlen(_id));
	}
	
	const char* method = HTTPGetMethod(context->_request->_method);
	addStrToHash(hash, "request-method", method, strlen(method));
	
	const char* uri = context->_request->_uri;
	addStrToHash(hash, "request-uri", uri, strlen(uri));
	
	const char* query = context->_request->_query == NULL ? "" : context->_request->_query;
	addStrToHash(hash, "request-query", query, strlen(query));
	
	VALUE hash_headers = rho_ruby_createHash();
    rho_ruby_holdValue(hash_headers);

	struct parsed_header* h = &context->_request->_cheaders.cl;
	for (int i = 0; i < sizeof(struct headers)/sizeof(struct parsed_header); i++) {
		if (h->_name) {
			char* name = trim(strdup(h->_name));
			if (h->_type == HDR_STRING) {
				addStrToHash(hash_headers,name,h->_v.v_vec.ptr,h->_v.v_vec.len);
			} else if (h->_type == HDR_INT) {
				addIntToHash(hash_headers, name, h->_v.v_big_int);
			} else if (h->_type == HDR_DATE) {
				addTimeToHash(hash_headers, name, h->_v.v_time);
			}
			free(name);
		}
		h++;
	}
	addHashToHash(hash,"headers",hash_headers);
    rho_ruby_releaseValue(hash_headers);

	int buflen = CFDataGetLength(context->_rcvdBytes);
	if (buflen > 0) {
		addStrToHash(hash, "request-body", 
					 (char*)CFDataGetBytePtr(context->_rcvdBytes), buflen);
	}

    rho_ruby_releaseValue(hash);
	return hash;
}