rhodes 2.2.6 → 2.3.0.beta.1

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

@@ -14,6 +14,56 @@ extern "C" void rho_nativethread_end(void *);
 std::string const &rho_root_path();
 std::string const &rho_apk_path();
 
+template <typename T>
+class jholder
+{
+public:
+    jholder(T obj) :m_object(obj) {}
+
+    jholder(jholder const &c)
+        :m_object(c.m_object)
+    {
+        if (m_object)
+            jnienv()->NewLocalRef(m_object);
+    }
+
+    ~jholder()
+    {
+        if (m_object)
+            jnienv()->DeleteLocalRef(m_object);
+    }
+
+    jholder &operator=(jholder const &rhs)
+    {
+        jholder copy(rhs);
+        swap(copy);
+        return *this;
+    }
+
+    T get() const {return m_object;}
+
+    T release()
+    {
+        T ret = m_object;
+        m_object = NULL;
+        return ret;
+    }
+
+    bool operator!() const {return !m_object;}
+
+private:
+    void swap(jholder &c)
+    {
+        std::swap(m_object, c.m_object);
+    }
+
+private:
+    T m_object;
+};
+
+typedef jholder<jobject> jhobject;
+typedef jholder<jstring> jhstring;
+
 namespace details
 {
 
@@ -27,27 +77,33 @@ struct rho_cast_helper<std::string, jstring>
 };
 
 template <>
-struct rho_cast_helper<jstring, char const *>
+struct rho_cast_helper<std::string, jhstring>
+{
+    std::string operator()(JNIEnv *env, jhstring s) {return rho_cast_helper<std::string, jstring>()(env, s.get());}
+};
+
+template <>
+struct rho_cast_helper<jhstring, char const *>
 {
-    jstring operator()(JNIEnv *env, char const *);
+    jhstring operator()(JNIEnv *env, char const *);
 };
 
 template <>
-struct rho_cast_helper<jstring, char *>
+struct rho_cast_helper<jhstring, char *>
 {
-    jstring operator()(JNIEnv *env, char *s) {return rho_cast_helper<jstring, char const *>()(env, s);}
+    jhstring operator()(JNIEnv *env, char *s) {return rho_cast_helper<jhstring, char const *>()(env, s);}
 };
 
 template <int N>
-struct rho_cast_helper<jstring, char [N]>
+struct rho_cast_helper<jhstring, char [N]>
 {
-    jstring operator()(JNIEnv *env, char (&s)[N]) {return rho_cast_helper<jstring, char const *>()(env, &s[0]);}
+    jhstring operator()(JNIEnv *env, char (&s)[N]) {return rho_cast_helper<jhstring, char const *>()(env, &s[0]);}
 };
 
 template <>
-struct rho_cast_helper<jstring, std::string>
+struct rho_cast_helper<jhstring, std::string>
 {
-    jstring operator()(JNIEnv *env, std::string const &s) {return rho_cast_helper<jstring, char const *>()(env, s.c_str());}
+    jhstring operator()(JNIEnv *env, std::string const &s) {return rho_cast_helper<jhstring, char const *>()(env, s.c_str());}
 };
 
 } // namespace details

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

@@ -3,6 +3,7 @@
 
 #include "rhodes/RhoClassFactory.h"
 #include "rhodes/sslimpl.h"
+#include "rhodes/rhocryptimpl.h"
 
 namespace rho
 {
@@ -24,6 +25,11 @@ net::ISSL *CRhoClassFactory::createSSLEngine()
     return new net::SSLImpl();
 }
 
+IRhoCrypt *CRhoClassFactory::createRhoCrypt()
+{
+    return new CRhoCryptImpl;
+}
+
 } // namespace common
 } // namespace rho
 

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

@@ -15,20 +15,18 @@ 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)
+RHO_GLOBAL void alert_show_status(const char* szTitle, 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");
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "showStatusPopup", "(Ljava/lang/String;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);
+    env->CallStaticVoidMethod(cls, mid, rho_cast<jhstring>(szTitle).get(),
+        rho_cast<jhstring>(szMessage).get(), rho_cast<jhstring>(szHide).get());
 }
 
 RHO_GLOBAL void alert_show_popup(rho_param *p)
@@ -81,10 +79,6 @@ RHO_GLOBAL void alert_play_file(char* file_name, char *media_type)
     jmethodID mid = getJNIClassStaticMethod(env, cls, "playFile", "(Ljava/lang/String;Ljava/lang/String;)V");
     if (!mid) return;
 
-    jstring objFileName = rho_cast<jstring>(file_name);
-    jstring objMediaType = media_type ? rho_cast<jstring>(media_type) : NULL;
-    env->CallStaticVoidMethod(cls, mid, objFileName, objMediaType);
-    env->DeleteLocalRef(objFileName);
-    if (objMediaType) env->DeleteLocalRef(objMediaType);
+    env->CallStaticVoidMethod(cls, mid, rho_cast<jhstring>(file_name).get(), rho_cast<jhstring>(media_type).get());
 }
 

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

@@ -20,6 +20,7 @@
 #include "rhodes/jni/com_rhomobile_rhodes_bluetooth_RhoBluetoothManager.h"
 
 #include <common/RhodesApp.h>
+#include "ruby/ext/rho/rhoruby.h"
 
 
 
@@ -57,9 +58,8 @@ RHO_GLOBAL void rho_bluetooth_set_device_name(const char* device_name) {
     if (!cls) return;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "set_device_name", "(Ljava/lang/String;)V");
     if (!mid) return;
-    jstring objDeviceName = rho_cast<jstring>(device_name);
-    env->CallStaticVoidMethod(cls, mid, objDeviceName);
-    env->DeleteLocalRef(objDeviceName);
+    jhstring objDeviceName = rho_cast<jhstring>(device_name);
+    env->CallStaticVoidMethod(cls, mid, objDeviceName.get());
 }
 
 RHO_GLOBAL const char* rho_bluetooth_get_device_name() {
@@ -91,11 +91,9 @@ RHO_GLOBAL const char* rho_bluetooth_create_session(const char* role, const char
     if (!cls) return 0;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "create_session", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");
     if (!mid) return 0;
-    jstring objStr1 = rho_cast<jstring>(role);
-    jstring objStr2 = rho_cast<jstring>(callback_url);
-    jstring res = (jstring)env->CallStaticObjectMethod(cls, mid, objStr1, objStr2);
-    env->DeleteLocalRef(objStr1);
-    env->DeleteLocalRef(objStr2);
+    jhstring objStr1 = rho_cast<jhstring>(role);
+    jhstring objStr2 = rho_cast<jhstring>(callback_url);
+    jhstring res = jhstring((jstring)env->CallStaticObjectMethod(cls, mid, objStr1.get(), objStr2.get()));
     return rho_cast<std::string>(res).c_str();
 }
 
@@ -105,11 +103,9 @@ RHO_GLOBAL void rho_bluetooth_session_set_callback(const char* connected_device_
     if (!cls) return;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "session_set_callback", "(Ljava/lang/String;Ljava/lang/String;)V");
     if (!mid) return;
-    jstring objStr1 = rho_cast<jstring>(connected_device_name);
-    jstring objStr2 = rho_cast<jstring>(callback_url);
-    env->CallStaticVoidMethod(cls, mid, objStr1, objStr2);
-    env->DeleteLocalRef(objStr1);
-    env->DeleteLocalRef(objStr2);
+    jhstring objStr1 = rho_cast<jhstring>(connected_device_name);
+    jhstring objStr2 = rho_cast<jhstring>(callback_url);
+    env->CallStaticVoidMethod(cls, mid, objStr1.get(), objStr2.get());
 }
 
 RHO_GLOBAL void rho_bluetooth_session_disconnect(const char* connected_device_name) {
@@ -118,9 +114,8 @@ RHO_GLOBAL void rho_bluetooth_session_disconnect(const char* connected_device_na
     if (!cls) return;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "session_disconnect", "(Ljava/lang/String;)V");
     if (!mid) return;
-    jstring objStr1 = rho_cast<jstring>(connected_device_name);
-    env->CallStaticVoidMethod(cls, mid, objStr1);
-    env->DeleteLocalRef(objStr1);
+    jhstring objStr1 = rho_cast<jhstring>(connected_device_name);
+    env->CallStaticVoidMethod(cls, mid, objStr1.get());
 }
 
 RHO_GLOBAL int rho_bluetooth_session_get_status(const char* connected_device_name) {
@@ -128,11 +123,9 @@ RHO_GLOBAL int rho_bluetooth_session_get_status(const char* connected_device_nam
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
     if (!cls) return 0;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "session_get_status", "(Ljava/lang/String;)I");
-    jstring objStr1 = rho_cast<jstring>(connected_device_name);
     if (!mid) return 0;
-    int res = env->CallStaticIntMethod(cls, mid, objStr1);
-    env->DeleteLocalRef(objStr1);
-    return res;
+    jhstring objStr1 = rho_cast<jhstring>(connected_device_name);
+    return env->CallStaticIntMethod(cls, mid, objStr1.get());
 }
 
 RHO_GLOBAL const char* rho_bluetooth_session_read_string(const char* connected_device_name) {
@@ -140,10 +133,9 @@ RHO_GLOBAL const char* rho_bluetooth_session_read_string(const char* connected_d
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
     if (!cls) return 0;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "session_read_string", "(Ljava/lang/String;)Ljava/lang/String;");
-    jstring objStr1 = rho_cast<jstring>(connected_device_name);
     if (!mid) return 0;
-    jstring res = (jstring)env->CallStaticObjectMethod(cls, mid, objStr1);
-    env->DeleteLocalRef(objStr1);
+    jhstring objStr1 = rho_cast<jhstring>(connected_device_name);
+    jhstring res = jhstring((jstring)env->CallStaticObjectMethod(cls, mid, objStr1.get()));
     return rho_cast<std::string>(res).c_str();
 }
 
@@ -153,17 +145,62 @@ RHO_GLOBAL void rho_bluetooth_session_write_string(const char* connected_device_
     if (!cls) return;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "session_write_string", "(Ljava/lang/String;Ljava/lang/String;)V");
     if (!mid) return;
-    jstring objStr1 = rho_cast<jstring>(connected_device_name);
-    jstring objStr2 = rho_cast<jstring>(str);
-    env->CallStaticVoidMethod(cls, mid, objStr1, objStr2);
-    env->DeleteLocalRef(objStr1);
-    env->DeleteLocalRef(objStr2);
+    jhstring objStr1 = rho_cast<jhstring>(connected_device_name);
+    jhstring objStr2 = rho_cast<jhstring>(str);
+    env->CallStaticVoidMethod(cls, mid, objStr1.get(), objStr2.get());
 }
 
 RHO_GLOBAL VALUE rho_bluetooth_session_read_data(const char* connected_device_name) {
-	return 0;
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
+    if (!cls) return 0;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "session_read_data", "(Ljava/lang/String;[BI)I");
+    if (!mid) return 0;
+    jhstring objStr1 = rho_cast<jhstring>(connected_device_name);
+
+    int buf_size = env->CallStaticIntMethod(cls, mid, objStr1.get(), 0, 0);
+
+    if (buf_size == 0) {
+        // nothing for receive
+	return rho_ruby_get_NIL();
+    }
+
+    jholder<jbyteArray> buf_j = jholder<jbyteArray>(env->NewByteArray(buf_size));
+    int real_readed = env->CallStaticIntMethod(cls, mid, objStr1.get(), buf_j.get(), buf_size);
+
+    jbyte* buf_p = env->GetByteArrayElements(buf_j.get(), 0);
+ 
+    VALUE val = rho_ruby_create_byte_array((unsigned char*)buf_p, real_readed);
+	
+    env->ReleaseByteArrayElements(buf_j.get(), buf_p, 0); 
+
+    return val;
 }
 
+// public static int session_read_data(String connected_device_name, byte[] buf, int max_length)
+// public static void session_write_data(String connected_device_name, byte[] buf, int length)
+
+
 RHO_GLOBAL void rho_bluetooth_session_write_data(const char* connected_device_name, VALUE data) {
+    int size = rho_ruby_unpack_byte_array(data, 0, 0);
+    if (size <= 0) {
+	return;
+    }
+
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
+    if (!cls) return;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "session_write_data", "(Ljava/lang/String;[BI)V");
+    if (!mid) return;
+    jhstring objStr1 = rho_cast<jhstring>(connected_device_name);
+
+    jholder<jbyteArray> buf_j = jholder<jbyteArray>(env->NewByteArray(size));
+    jbyte* buf_p = env->GetByteArrayElements(buf_j.get(), 0);
+
+    size = rho_ruby_unpack_byte_array(data, (unsigned char*)buf_p, size);
+
+    env->CallStaticVoidMethod(cls, mid, objStr1.get(), buf_j.get(), size);
+
+    env->ReleaseByteArrayElements(buf_j.get(), buf_p, 0); 
 }
 

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

@@ -51,9 +51,8 @@ RHO_GLOBAL void delete_files_in_folder(const char *szFolderPath)
     if (!cls) return;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "deleteFilesInFolder", "(Ljava/lang/String;)V");
     if (!mid) return;
-    jstring objFolderPath = rho_cast<jstring>(szFolderPath);
-    env->CallStaticVoidMethod(cls, mid, objFolderPath);
-    env->DeleteLocalRef(objFolderPath);
+    jhstring objFolderPath = rho_cast<jhstring>(szFolderPath);
+    env->CallStaticVoidMethod(cls, mid, objFolderPath.get());
 }
 
 RHO_GLOBAL VALUE rho_sys_makephonecall(const char* callname, int nparams, char** param_names, char** param_values)
@@ -95,9 +94,8 @@ RHO_GLOBAL int rho_sysimpl_get_property(char* szPropName, VALUE* resValue)
     jmethodID mid = getJNIClassStaticMethod(env, cls, "getProperty", "(Ljava/lang/String;)Ljava/lang/Object;");
     if (!mid) return 0;
 
-    jstring propNameObj = rho_cast<jstring>(szPropName);
-    jobject result = env->CallStaticObjectMethod(cls, mid, propNameObj);
-    env->DeleteLocalRef(propNameObj);
+    jhstring propNameObj = rho_cast<jhstring>(szPropName);
+    jhobject result = jhobject(env->CallStaticObjectMethod(cls, mid, propNameObj.get()));
     if (!result) return 0;
 
     jclass clsBoolean = getJNIClass(RHODES_JAVA_CLASS_BOOLEAN);
@@ -106,34 +104,29 @@ RHO_GLOBAL int rho_sysimpl_get_property(char* szPropName, VALUE* resValue)
     jclass clsDouble = getJNIClass(RHODES_JAVA_CLASS_DOUBLE);
     jclass clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
 
-    if (env->IsInstanceOf(result, clsBoolean)) {
+    if (env->IsInstanceOf(result.get(), clsBoolean)) {
         jmethodID midValue = getJNIClassMethod(env, clsBoolean, "booleanValue", "()Z");
-        *resValue = rho_ruby_create_boolean((int)env->CallBooleanMethod(result, midValue));
-        env->DeleteLocalRef(result);
+        *resValue = rho_ruby_create_boolean((int)env->CallBooleanMethod(result.get(), midValue));
         return 1;
     }
-    else if (env->IsInstanceOf(result, clsInteger)) {
+    else if (env->IsInstanceOf(result.get(), clsInteger)) {
         jmethodID midValue = getJNIClassMethod(env, clsInteger, "intValue", "()I");
-        *resValue = rho_ruby_create_integer((int)env->CallIntMethod(result, midValue));
-        env->DeleteLocalRef(result);
+        *resValue = rho_ruby_create_integer((int)env->CallIntMethod(result.get(), midValue));
         return 1;
     }
-    else if (env->IsInstanceOf(result, clsFloat)) {
+    else if (env->IsInstanceOf(result.get(), clsFloat)) {
         jmethodID midValue = getJNIClassMethod(env, clsFloat, "floatValue", "()F");
-        *resValue = rho_ruby_create_double((double)env->CallFloatMethod(result, midValue));
-        env->DeleteLocalRef(result);
+        *resValue = rho_ruby_create_double((double)env->CallFloatMethod(result.get(), midValue));
         return 1;
     }
-    else if (env->IsInstanceOf(result, clsDouble)) {
+    else if (env->IsInstanceOf(result.get(), clsDouble)) {
         jmethodID midValue = getJNIClassMethod(env, clsDouble, "doubleValue", "()D");
-        *resValue = rho_ruby_create_double((double)env->CallDoubleMethod(result, midValue));
-        env->DeleteLocalRef(result);
+        *resValue = rho_ruby_create_double((double)env->CallDoubleMethod(result.get(), midValue));
         return 1;
     }
-    else if (env->IsInstanceOf(result, clsString)) {
-        jstring resStrObj = (jstring)result;
+    else if (env->IsInstanceOf(result.get(), clsString)) {
+        jstring resStrObj = (jstring)result.get();
         *resValue = rho_ruby_create_string(rho_cast<std::string>(resStrObj).c_str());
-        env->DeleteLocalRef(result);
         return 1;
     }
 
@@ -218,6 +211,16 @@ RHO_GLOBAL int rho_sys_is_app_installed(const char *appname)
     return (int)env->CallStaticBooleanMethod(cls, mid, env->NewStringUTF(appname));
 }
 
+RHO_GLOBAL void rho_sys_app_install(const char *url)
+{
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
+    if (!cls) return;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "installApplication", "(Ljava/lang/String;)V");
+    if (!mid) return;
+    env->CallStaticVoidMethod(cls, mid, env->NewStringUTF(url));
+}
+
 RHO_GLOBAL void rho_sys_app_uninstall(const char *appname)
 {
     JNIEnv *env = jnienv();

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

@@ -21,9 +21,7 @@ RHO_GLOBAL void take_picture(char* callback_url)
     if (!cls) return;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "takePicture", "(Ljava/lang/String;)V");
     if (!mid) return;
-    jstring objCallback = rho_cast<jstring>(callback_url);
-    env->CallStaticVoidMethod(cls, mid, objCallback);
-    env->DeleteLocalRef(objCallback);
+    env->CallStaticVoidMethod(cls, mid, rho_cast<jhstring>(callback_url).get());
 }
 
 RHO_GLOBAL void choose_picture(char* callback_url)
@@ -33,8 +31,6 @@ RHO_GLOBAL void choose_picture(char* callback_url)
     if (!cls) return;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "choosePicture", "(Ljava/lang/String;)V");
     if (!mid) return;
-    jstring objCallback = rho_cast<jstring>(callback_url);
-    env->CallStaticVoidMethod(cls, mid, objCallback);
-    env->DeleteLocalRef(objCallback);
+    env->CallStaticVoidMethod(cls, mid, rho_cast<jhstring>(callback_url).get());
 }
 

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

@@ -15,24 +15,26 @@ RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_datetime_DateTimePicker_callba
     env->ReleaseByteArrayElements(opaqueObj, opaqueStr, 0);
 }
 
-RHO_GLOBAL void choose_datetime(char* callback, char* title, long initial_time, int format, char* data)
+RHO_GLOBAL void choose_datetime_with_range(char* callback, char* title, long initial_time, int format, char* data, long min_time, long max_time)
 {
     JNIEnv *env = jnienv();
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_DATE_TIME_PICKER);
     if (!cls) return;
-    jmethodID mid = getJNIClassStaticMethod(env, cls, "choose", "(Ljava/lang/String;Ljava/lang/String;JI[B)V");
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "choose", "(Ljava/lang/String;Ljava/lang/String;JI[BJJ)V");
     if (!mid) return;
 
     jsize data_size = strlen(data);
-    jbyteArray opaqueObj = env->NewByteArray(data_size);
+    jholder<jbyteArray> opaqueObj = jholder<jbyteArray>(env->NewByteArray(data_size));
     if (!opaqueObj) return;
-    env->SetByteArrayRegion(opaqueObj, 0, data_size, (const jbyte *)data);
-    jstring objCallback = rho_cast<jstring>(callback);
-    jstring objTitle = rho_cast<jstring>(title);
-    env->CallStaticVoidMethod(cls, mid, objCallback, objTitle,
-        (jlong)initial_time, format, opaqueObj);
-    env->DeleteLocalRef(objCallback);
-    env->DeleteLocalRef(objTitle);
-    env->DeleteLocalRef(opaqueObj);
+    env->SetByteArrayRegion(opaqueObj.get(), 0, data_size, (const jbyte *)data);
+    jhstring objCallback = rho_cast<jhstring>(callback);
+    jhstring objTitle = rho_cast<jhstring>(title);
+    env->CallStaticVoidMethod(cls, mid, objCallback.get(), objTitle.get(),
+        (jlong)initial_time, format, opaqueObj.get(), (jlong)min_time, (jlong)max_time);
+}
+
+RHO_GLOBAL void choose_datetime(char* callback, char* title, long initial_time, int format, char* data)
+{
+    choose_datetime_with_range(callback, title, initial_time, format, data, 0, 0);
 }
 

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

@@ -367,24 +367,20 @@ RHO_GLOBAL VALUE event_fetch_by_id(const char *id)
     if (!clsString) return Qnil;
 
     RHO_TRACE("event_fetch_by_id (1)");
-    jstring jId = rho_cast<jstring>(env, id);
+    jhstring jId = rho_cast<jhstring>(env, id);
     RHO_TRACE("event_fetch_by_id (2)");
-    jobject jRet = env->CallStaticObjectMethod(cls, mid, jId);
+    jhobject jRet = jhobject(env->CallStaticObjectMethod(cls, mid, jId.get()));
     RHO_TRACE("event_fetch_by_id (3)");
-    if (env->IsInstanceOf(jRet, clsString))
+    if (env->IsInstanceOf(jRet.get(), clsString))
     {
         RHO_TRACE("event_fetch_by_id (3.1)");
-        std::string error = rho_cast<std::string>(env, (jstring)jRet);
+        std::string error = rho_cast<std::string>(env, (jstring)jRet.get());
         RHO_TRACE("event_fetch_by_id (3.2)");
-        env->DeleteLocalRef(jRet);
-        RHO_TRACE("event_fetch_by_id (3.3)");
         rb_raise(rb_eRuntimeError, "Can't fetch event with id %s: %s", id, error.c_str());
         return Qnil;
     }
-    VALUE rEvent = event_cast<VALUE>(jRet);
+    VALUE rEvent = event_cast<VALUE>(jRet.get());
     RHO_TRACE("event_fetch_by_id (4)");
-    env->DeleteLocalRef(jId);
-    env->DeleteLocalRef(jRet);
     return rEvent;
 }
 
@@ -416,14 +412,12 @@ RHO_GLOBAL void event_delete(const char *id)
     jmethodID mid = getJNIClassStaticMethod(env, cls, "delete", "(Ljava/lang/String;)Ljava/lang/String;");
     if (!mid) return;
 
-    jstring jId = rho_cast<jstring>(env, id);
-    jstring jError = (jstring)env->CallStaticObjectMethod(cls, mid, jId);
-    env->DeleteLocalRef(jId);
+    jhstring jId = rho_cast<jhstring>(env, id);
+    jhstring jError = jhstring((jstring)env->CallStaticObjectMethod(cls, mid, jId.get()));
 
-    if (jError)
+    if (!!jError)
     {
-        std::string error = rho_cast<std::string>(env, jError);
-        env->DeleteLocalRef(jError);
+        std::string error = rho_cast<std::string>(env, jError.get());
         rb_raise(rb_eRuntimeError, "Event delete failed: %s", error.c_str());
     }
 }

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

@@ -246,7 +246,7 @@ RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_file_RhoFileApi_normalizePa
   (JNIEnv *env, jclass, jstring pathObj)
 {
     std::string path = normalize_path(rho_cast<std::string>(env, pathObj));
-    return rho_cast<jstring>(env, path);
+    return rho_cast<jhstring>(env, path).release();
 }
 
 static std::string make_full_path(const char *path)
@@ -278,7 +278,7 @@ RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_file_RhoFileApi_makeRelativ
   (JNIEnv *env, jclass, jstring pathObj)
 {
     std::string path = rho_cast<std::string>(env, pathObj);
-    return rho_cast<jstring>(env, make_rel_path(make_full_path(path)));
+    return rho_cast<jhstring>(env, make_rel_path(make_full_path(path))).release();
 }
 
 static rho_stat_t *rho_stat(const char *path)
@@ -417,9 +417,8 @@ RHO_GLOBAL int open(const char *path, int oflag, ...)
     {
         //RHO_LOG("open: %s: copy from Android package", path);
         JNIEnv *env = jnienv();
-        jstring relPathObj = rho_cast<jstring>(env, make_rel_path(fpath).c_str());
-        env->CallStaticBooleanMethod(clsFileApi, midCopy, relPathObj);
-        env->DeleteLocalRef(relPathObj);
+        jhstring relPathObj = rho_cast<jhstring>(env, make_rel_path(fpath).c_str());
+        env->CallStaticBooleanMethod(clsFileApi, midCopy, relPathObj.get());
         if (has_pending_exception())
         {
             errno = EFAULT;
@@ -433,11 +432,15 @@ RHO_GLOBAL int open(const char *path, int oflag, ...)
     if (java_way)
     {
         JNIEnv *env = jnienv();
-        jstring relPathObj = rho_cast<jstring>(env, make_rel_path(fpath).c_str());
-        jobject is = env->CallStaticObjectMethod(clsFileApi, midOpen, relPathObj);
-        env->DeleteLocalRef(relPathObj);
+        jhstring relPathObj = rho_cast<jhstring>(env, make_rel_path(fpath).c_str());
+        jhobject is = jhobject(env->CallStaticObjectMethod(clsFileApi, midOpen, relPathObj.get()));
 
-        if (is != NULL)
+        if (!is)
+        {
+            errno = EFAULT;
+            fd = -1;
+        }
+        else
         {
             scoped_lock_t guard(rho_fd_mtx);
             if (!rho_fd_free.empty())
@@ -448,18 +451,11 @@ RHO_GLOBAL int open(const char *path, int oflag, ...)
             else
                 fd = rho_fd_counter++;
             rho_fd_data_t d;
-            d.is = env->NewGlobalRef(is);
+            d.is = env->NewGlobalRef(is.get());
             d.fpath = fpath;
             d.pos = 0;
             rho_fd_map[fd] = d;
         }
-        else
-        {
-            errno = EFAULT;
-            fd = -1;
-        }
-
-        env->DeleteLocalRef(is);
     }
     else
     {
@@ -670,16 +666,6 @@ RHO_GLOBAL int lchown(const char *path, uid_t uid, gid_t gid)
     RHO_NOT_IMPLEMENTED;
 }
 
-RHO_GLOBAL int chmod(const char *path, mode_t mode)
-{
-    RHO_NOT_IMPLEMENTED;
-}
-
-RHO_GLOBAL int fchmod(int fd, mode_t mode)
-{
-    RHO_NOT_IMPLEMENTED;
-}
-
 RHO_GLOBAL int mknod(const char *path, mode_t mode, dev_t dev)
 {
     RHO_NOT_IMPLEMENTED;

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

@@ -7,7 +7,7 @@
 RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhoLogConf_getEnabledCategories
   (JNIEnv *env, jobject)
 {
-    return rho_cast<jstring>(LOGCONF().getEnabledCategories().c_str());
+    return rho_cast<jhstring>(LOGCONF().getEnabledCategories().c_str()).release();
 }
 
 RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhoLogConf_setEnabledCategories
@@ -21,7 +21,7 @@ RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhoLogConf_setEnabledCategorie
 RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhoLogConf_getDisabledCategories
   (JNIEnv *env, jobject)
 {
-    return rho_cast<jstring>(LOGCONF().getDisabledCategories().c_str());
+    return rho_cast<jhstring>(LOGCONF().getDisabledCategories().c_str()).release();
 }
 
 RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhoLogConf_setDisabledCategories
@@ -61,7 +61,7 @@ RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhoLogConf_getLogText
 {
     rho::String logText;
     LOGCONF().getLogText(logText);
-    return rho_cast<jstring>(logText.c_str());
+    return rho_cast<jhstring>(logText.c_str()).release();
 }
 
 RHO_GLOBAL jint JNICALL Java_com_rhomobile_rhodes_RhoLogConf_getLogTextPos