rhodes 2.2.4.beta.1 → 2.2.5.beta.1

data/platform/android/Rhodes/jni/include/rhodes/JNIRhodes.h

@@ -35,8 +35,6 @@ jfieldID getJNIClassStaticField(JNIEnv *env, jclass cls, const char *name, const
 jmethodID getJNIClassMethod(JNIEnv *env, jclass cls, const char *name, const char *signature);
 jmethodID getJNIClassStaticMethod(JNIEnv *env, jclass cls, const char *name, const char *signature);
 
-VALUE convertJavaMapToRubyHash(jobject objMap);
-
 #define RHO_NOT_IMPLEMENTED RAWLOG_ERROR3("WARNING: Call not implemented function: \"%s\" (defined here: %s:%d)", __PRETTY_FUNCTION__, __FILE__, __LINE__)
 
 #define RHO_LOG_CALLBACK RAWLOG_INFO1("Callback \"%s\" called", __PRETTY_FUNCTION__)
@@ -62,5 +60,22 @@ public:
     jobject createObject(rho_param *p);
 };
 
+namespace details
+{
+
+template <>
+struct rho_cast_helper<VALUE, jobject>
+{
+    VALUE operator()(JNIEnv *env, jobject obj);
+};
+
+template <>
+struct rho_cast_helper<jobject, VALUE>
+{
+    jobject operator()(JNIEnv *env, VALUE value);
+};
+
+} // namespace details
+
 #endif // RHO_JNI_RHODES_57d3a700b706402190ead97fd1383bee
 

data/platform/android/Rhodes/jni/src/alert.cpp

@@ -15,6 +15,22 @@ RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_alert_Alert_doCallback
         rho_cast<std::string>(env, id).c_str(), rho_cast<std::string>(env, title).c_str());
 }
 
+RHO_GLOBAL void alert_show_status(const char* szMessage, const char* szHide)
+{
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_ALERT);
+    if (!cls) return;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "showStatusPopup", "(Ljava/lang/String;Ljava/lang/String;)V");
+    if (!mid) return;
+
+    RAWLOG_INFO("alert_show_status");
+
+    jstring strMsg = rho_cast<jstring>(szMessage);
+    jstring strHide = rho_cast<jstring>(szHide);
+    env->CallStaticVoidMethod(cls, mid, strMsg, strHide);
+    env->DeleteLocalRef(strMsg);
+}
+
 RHO_GLOBAL void alert_show_popup(rho_param *p)
 {
     JNIEnv *env = jnienv();

data/platform/android/Rhodes/jni/src/callbacks.cpp

@@ -68,6 +68,11 @@ RHO_GLOBAL void rho_net_impl_network_indicator(int enable)
     // No GUI indicator on Android
 }
 
+RHO_GLOBAL int rho_net_ping_network(const char* szHost)
+{
+    return 0;
+}
+
 RHO_GLOBAL void *rho_nativethread_start()
 {
     JNIEnv *env;
@@ -187,10 +192,9 @@ RHO_GLOBAL void rho_sys_run_app(const char *appname, VALUE params)
     JNIEnv *env = jnienv();
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
     if (!cls) return;
-    jmethodID mid = getJNIClassStaticMethod(env, cls, "runApplication", "(Ljava/lang/String;Ljava/util/Map;)V");
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "runApplication", "(Ljava/lang/String;Ljava/lang/Object;)V");
     if (!mid) return;
-    // TODO: convert ruby hash (params) to java map (jParams)
-    jobject jParams = NULL;
+    jobject jParams = rho_cast<jobject>(env, params);
     env->CallStaticVoidMethod(cls, mid, env->NewStringUTF(appname), jParams);
 }
 
@@ -203,3 +207,23 @@ RHO_GLOBAL void rho_sys_open_url(const char *url)
     if (!mid) return;
     env->CallStaticVoidMethod(cls, mid, env->NewStringUTF(url));
 }
+
+RHO_GLOBAL int rho_sys_is_app_installed(const char *appname)
+{
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
+    if (!cls) return 0;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "isAppInstalled", "(Ljava/lang/String;)Z");
+    if (!mid) return 0;
+    return (int)env->CallStaticBooleanMethod(cls, mid, env->NewStringUTF(appname));
+}
+
+RHO_GLOBAL void rho_sys_app_uninstall(const char *appname)
+{
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
+    if (!cls) return;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "uninstallApplication", "(Ljava/lang/String;)V");
+    if (!mid) return;
+    env->CallStaticVoidMethod(cls, mid, env->NewStringUTF(appname));
+}

data/platform/android/Rhodes/jni/src/nativebar.cpp

@@ -60,3 +60,6 @@ RHO_GLOBAL VALUE nativebar_started()
 
     return rho_ruby_create_boolean(env->CallStaticBooleanMethod(cls, mid));
 }
+
+RHO_GLOBAL void nativebar_set_tab_badge(int index,char *val) {
+}

data/platform/android/Rhodes/jni/src/nativeview.cpp

@@ -6,16 +6,100 @@
 
 
 #include <stdlib.h>
+#include <strings.h>
 
 
-#import <RhoNativeViewManager.h> 
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "NativeView"
 
+#define logging_enable false
+
+
+
+#include <RhoNativeViewManager.h> 
+
+
+class RhoNativeViewHolder{
+  public :
+	RhoNativeViewHolder() {
+		factory = NULL;
+		next = NULL;
+		viewtype = NULL;
+	}
+	virtual ~RhoNativeViewHolder() {
+		if (viewtype != NULL) {
+			delete viewtype;
+		}
+	}
+	void setViewType(const char* viewtypename) {
+		viewtype = new char[strlen(viewtypename)+2];
+		strcpy(viewtype, viewtypename);
+	}
+	bool isApplicable(const char* viewtypename) {
+		return (strcmp(viewtype, viewtypename) == 0);
+	}
+	char* viewtype;
+	NativeViewFactory* factory;
+	RhoNativeViewHolder* next;
+};
+
+static RhoNativeViewHolder* first = NULL;
+
+
+static void addRhoNativeViewHolder(RhoNativeViewHolder* holder) {
+	if (first == NULL) {
+		first = holder;
+		holder->next = NULL;
+	}
+	else {
+		holder->next = first;
+		first = holder;
+	}
+}
+
+static void removeRhoNativeViewHolder(RhoNativeViewHolder* holder) {
+	RhoNativeViewHolder* p = first;
+	RhoNativeViewHolder* prev = NULL;
+	while (p != NULL) {
+		if (p == holder) {
+			RhoNativeViewHolder* next = p->next;
+			if (prev != NULL) {
+				prev->next = next;
+			}
+			if (first == p) {
+				first = NULL;
+			}
+			delete p;
+		}
+		prev = p;
+		p = p->next;
+	}
+}
+
+static RhoNativeViewHolder* getHolderByViewTypeName(const char* name) {
+	RhoNativeViewHolder* p = first;
+	while (p != NULL) {
+		if (p->isApplicable(name)) {
+			return p;
+		}
+		p = p->next;
+	}
+	return NULL;
+}
 
 
 void RhoNativeViewManager::registerViewType(const char* viewType, NativeViewFactory* factory) {
+	RhoNativeViewHolder* holder = new RhoNativeViewHolder();
+	holder->factory = factory;
+	holder->setViewType(viewType);
+	addRhoNativeViewHolder(holder);
 }
 
 void RhoNativeViewManager::unregisterViewType(const char* viewType) {
+	RhoNativeViewHolder* holder = getHolderByViewTypeName(viewType);
+	if (holder != NULL) {
+		removeRhoNativeViewHolder(holder);
+	}
 }
 
 // that function return native object used for display Web content :
@@ -32,4 +116,50 @@ void* RhoNativeViewManager::getWebViewObject(int tab_index) {
 }
 
 
+RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhodes_nativeview_RhoNativeViewManager_getViewByHandle
+(JNIEnv *env, jclass, jlong handle) {
+	NativeView* p = (NativeView*)handle;
+	if (p == NULL) {
+		return NULL;
+	}
+	return (jobject)(p->getView());
+}
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_nativeview_RhoNativeViewManager_navigateByHandle
+(JNIEnv *env, jclass, jlong handle, jstring url) {
+    	if (logging_enable) RAWLOG_INFO("navigateByHandle() START");
+
+	NativeView* p = (NativeView*)handle;
+	if (p != NULL) {
+    		if (logging_enable) RAWLOG_INFO("navigateByHandle() handle not NULL");
+		p->navigate(rho_cast<std::string>(url).c_str());
+	}
+    	if (logging_enable) RAWLOG_INFO("navigateByHandle() FINISH");
+}
+
+RHO_GLOBAL jlong JNICALL Java_com_rhomobile_rhodes_nativeview_RhoNativeViewManager_getFactoryHandleByViewType
+(JNIEnv *env, jclass, jstring viewtype) {
+	const char* s_viewtype = rho_cast<std::string>(viewtype).c_str();
+	RhoNativeViewHolder* nvh = getHolderByViewTypeName(s_viewtype);
+	return (jlong)((unsigned long int)nvh);
+}
+
+RHO_GLOBAL jlong JNICALL Java_com_rhomobile_rhodes_nativeview_RhoNativeViewManager_getViewHandleByFactoryHandle
+(JNIEnv *env, jclass, jlong factory_h) {
+	RhoNativeViewHolder* holder = (RhoNativeViewHolder*)factory_h;
+	if (holder == NULL) {
+		return 0;
+	}
+	return (jlong)((unsigned long int)holder->factory->getNativeView((const char*)holder->viewtype));
+}
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_nativeview_RhoNativeViewManager_destroyByHandle
+(JNIEnv *env, jclass, jlong factory_h, jlong view_h) {
+	RhoNativeViewHolder* holder = (RhoNativeViewHolder*)factory_h;
+	NativeView* nv = (NativeView*)view_h;
+	if ((holder == NULL) || (nv == NULL)) {
+		return;
+	}
+	holder->factory->destroyNativeView(nv);
+}
 

data/platform/android/Rhodes/jni/src/phonebook.cpp

@@ -1,8 +1,27 @@
 #include "rhodes/JNIRhodes.h"
 
+#include <android/log.h>
+#include <logging/RhoLogConf.h>
+
 #undef DEFAULT_LOGCATEGORY
 #define DEFAULT_LOGCATEGORY "Phonebook"
 
+#define logging_enable false
+
+
+#define PB_FIELDS_COUNT 8
+
+static const char* field_names[PB_FIELDS_COUNT] = {
+"id", // 0
+"first_name",  // 1
+"last_name",  // 2
+"mobile_number", // 3
+"home_number",  // 4
+"business_number",  // 5
+"email_address",  // 6
+"company_name"  // 7
+};
+
 RHO_GLOBAL void* openPhonebook()
 {
     JNIEnv *env = jnienv();
@@ -32,52 +51,34 @@ RHO_GLOBAL void closePhonebook(void* pb)
 
 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 contactMoveToBeginMID = getJNIClassMethod(env, contactCls, "moveToBegin", "()V");
-    if (!contactMoveToBeginMID) return Qnil;
-    jmethodID hasNextMID = getJNIClassMethod(env, contactCls, "hasNext", "()Z");
-    if (!hasNextMID) return Qnil;
-    jmethodID nextMID = getJNIClassMethod(env, contactCls, "next", "()Ljava/lang/Object;");
-    if (!nextMID) return Qnil;
-    jmethodID getKeyMID = getJNIClassMethod(env, fieldCls, "getKey", "()Ljava/lang/String;");
-    if (!getKeyMID) return Qnil;
-    jmethodID getValueMID = getJNIClassMethod(env, fieldCls, "getValue", "()Ljava/lang/String;");
-    if (!getValueMID) return Qnil;
+    jmethodID contactGetFieldMID = getJNIClassMethod(env, contactCls, "getField", "(I)Ljava/lang/String;");
+    if (!contactGetFieldMID) return Qnil;
 
     CHoldRubyValue contactHash(rho_ruby_createHash());
     // contact.moveToBegin();
-    env->CallVoidMethod(contactObj, contactMoveToBeginMID);
-
-    // while(contact.hasNext())
-    while(env->CallBooleanMethod(contactObj, hasNextMID))
-    {
-        // Contact.Field entry = (Contact.Field)contact.next();
-        jobject entryObj = env->CallObjectMethod(contactObj, nextMID);
-        if (!entryObj) return Qnil;
-        // String key = entry.getKey();
-        jstring keyObj = (jstring)env->CallObjectMethod(entryObj, getKeyMID);
-        if (!keyObj) return Qnil;
-        // String value = entry.getValue();
-        jstring valueObj = (jstring)env->CallObjectMethod(entryObj, getValueMID);
-        if (!valueObj) return Qnil;
-
-        addStrToHash(contactHash, rho_cast<std::string>(keyObj).c_str(), rho_cast<std::string>(valueObj).c_str());
-
-        env->DeleteLocalRef(valueObj);
-        env->DeleteLocalRef(keyObj);
-        env->DeleteLocalRef(entryObj);
-    }
 
+	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;
 }
 
 RHO_GLOBAL VALUE getallPhonebookRecords(void* pb)
 {
+    if (logging_enable) RAWLOG_INFO("getallPhonebookRecords() START");
     jobject phonebookObj = (jobject)pb;
 
     JNIEnv *env = jnienv();
@@ -87,6 +88,9 @@ RHO_GLOBAL VALUE getallPhonebookRecords(void* pb)
     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");
@@ -96,9 +100,16 @@ RHO_GLOBAL VALUE getallPhonebookRecords(void* pb)
     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())
@@ -111,18 +122,33 @@ RHO_GLOBAL VALUE getallPhonebookRecords(void* pb)
         jstring idObj = (jstring)env->CallObjectMethod(contactObj, contactIdMID);
         if (!idObj) return Qnil;
 
-        addHashToHash(hash, rho_cast<std::string>(idObj).c_str(), createHashFromContact(contactObj));
+        //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;
 }
 
 RHO_GLOBAL void* openPhonebookRecord(void* pb, char* id)
 {
+    if (logging_enable) RAWLOG_INFO("openPhonebookRecord() START");
     JNIEnv *env = jnienv();
     jobject obj = (jobject)pb;
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_PHONEBOOK);
@@ -136,32 +162,50 @@ RHO_GLOBAL void* openPhonebookRecord(void* pb, char* id)
     if (!recordObj) return NULL;
     jobject retval = env->NewGlobalRef(recordObj);
     env->DeleteLocalRef(recordObj);
+    if (logging_enable) RAWLOG_INFO("openPhonebookRecord() FINISH");
     if (!retval) return NULL;
     return retval;
 }
 
 RHO_GLOBAL VALUE getPhonebookRecord(void* pb, char* id)
 {
+    if (logging_enable) RAWLOG_INFO("getPhonebookRecord() START");
     jobject recordObj = (jobject)openPhonebookRecord(pb, id);
-    if (!recordObj)
+    if (!recordObj) {
+	if (logging_enable) RAWLOG_INFO("getPhonebookRecord() FINISH return NIL");
         return Qnil;
+    }
     VALUE retval = createHashFromContact(recordObj);
     jnienv()->DeleteGlobalRef(recordObj);
+    if (logging_enable) RAWLOG_INFO("getPhonebookRecord() FINISH");
     return retval;
 }
 
 static VALUE getRecord(void *pb, const char *name)
 {
+    if (logging_enable) RAWLOG_INFO("getRecord() START");
     jobject obj = (jobject)pb;
     JNIEnv *env = jnienv();
+    if (!env) {
+        if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL0");
+        return Qnil;
+    }
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_PHONEBOOK);
-    if (!cls) return Qnil;
+    if (!cls) {
+        if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL1");
+	return Qnil;
+    }
     jmethodID mid = getJNIClassMethod(env, cls, name, "()Lcom/rhomobile/rhodes/phonebook/Contact;");
-    if (!mid) return Qnil;
-
+    if (!mid) {
+        if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL2");
+	return Qnil; 
+    }	
     jobject recordObj = env->CallObjectMethod(obj, mid);
-    if (!recordObj)
+    if (!recordObj) {
+        if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL");
         return Qnil;
+    }
+    if (logging_enable) RAWLOG_INFO("getRecord() FINISH");
     return createHashFromContact(recordObj);
 }
 
@@ -189,19 +233,36 @@ RHO_GLOBAL void* createRecord(void* pb)
     return obj;
 }
 
+int get_value_index_by_name(char* name) {
+	int i;
+	for (i = 0; i < PB_FIELDS_COUNT; i++) {
+		if (strcmp(name, field_names[i]) == 0) {
+			return i;
+		}
+	}
+	return -1;
+}
+
 RHO_GLOBAL int setRecordValue(void* record, char* property, char* value)
 {
     jobject contactObj = (jobject)record;
     JNIEnv *env = jnienv();
     jclass contactCls = getJNIClass(RHODES_JAVA_CLASS_CONTACT);
     if (!contactCls) return 0;
-    jmethodID mid = getJNIClassMethod(env, contactCls, "setField", "(Ljava/lang/String;Ljava/lang/String;)V");
+    jmethodID mid = getJNIClassMethod(env, contactCls, "setField", "(ILjava/lang/String;)V");
     if (!mid) return 0;
 
-    jstring objProperty = rho_cast<jstring>(property);
+    //jstring objProperty = rho_cast<jstring>(property);
     jstring objValue = rho_cast<jstring>(value);
-    env->CallVoidMethod(contactObj, mid, objProperty, objValue);
-    env->DeleteLocalRef(objProperty);
+
+	int index = get_value_index_by_name(property);
+	if (index >= 0) {
+		env->CallVoidMethod(contactObj, mid, index, objValue);
+	}
+	else {
+		RAWLOG_ERROR("Phonebook.cpp invalid property name for Contact Record");
+	}
+    //env->DeleteLocalRef(objProperty);
     env->DeleteLocalRef(objValue);
     return 1;
 }