rhodes 3.2.3 → 3.3.0.beta.1

data/lib/framework/version.rb

@@ -1,6 +1,6 @@
 module RhodesFramework
   unless defined? RhodesFramework::VERSION
-    VERSION = '3.2.1'
+    VERSION = '3.3.0'
   end
   unless defined? RhodesFramework::DBVERSION
     DBVERSION = '2.2.2'

data/lib/rhodes.rb

@@ -1,6 +1,6 @@
 module Rhodes
   unless defined? Rhodes::VERSION
-    VERSION = '3.2.1'
+    VERSION = '3.3.0'
   end
   unless defined? Rhodes::DBVERSION
     DBVERSION = '2.2.0'

data/platform/android/Rhodes/jni/Application.mk

@@ -1,3 +1,4 @@
 APP_STL := stlport_static
-APP_CFLAGS += --sysroot $(NDK_ROOT)/platforms/android-9/arch-arm -DOS_ANDROID
+APP_CFLAGS += --sysroot $(NDK_ROOT)/platforms/android-14/arch-arm -DOS_ANDROID
+#APP_CFLAGS += --sysroot $(NDK_ROOT)/platforms/android-9/arch-arm -DOS_ANDROID
 #APP_CFLAGS += --sysroot /home/lexis/android/android-ndk-r6/platforms/android-9/arch-arm -DOS_ANDROID

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

@@ -94,6 +94,7 @@ typedef jholder<jstring> jhstring;
 
 namespace rho {
     template <typename K, typename V> class Hashtable;
+    template <typename T> class Vector;
 }
 typedef std::auto_ptr<rho::Hashtable<std::string, std::string> > hashtableholder;
 
@@ -183,6 +184,14 @@ struct rho_cast_helper<std::auto_ptr<rho::Hashtable<std::string,std::string> >,
     value_type operator()(JNIEnv *env, jobjectArray jKeys, jobjectArray jVals);
 };
 
+template <>
+struct rho_cast_helper<std::auto_ptr<rho::Vector<std::string> >, jobjectArray>
+{
+    typedef rho::Vector<std::string> element_type;
+    typedef std::auto_ptr<element_type> value_type;
+    value_type operator()(JNIEnv *env, jobjectArray jArr);
+};
+
 } // namespace details
 
 template <typename T, typename U>

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

@@ -58,7 +58,7 @@ RHO_GLOBAL VALUE rho_sys_has_network()
     return rho_ruby_create_boolean(env->CallStaticBooleanMethod(cls, mid));
 }
 
-RHO_GLOBAL void delete_files_in_folder(const char *szFolderPath)
+RHO_GLOBAL void rho_file_impl_delete_files_in_folder(const char *szFolderPath)
 {
     JNIEnv *env = jnienv();
     jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
@@ -69,6 +69,36 @@ RHO_GLOBAL void delete_files_in_folder(const char *szFolderPath)
     env->CallStaticVoidMethod(cls, mid, objFolderPath.get());
 }
 
+RHO_GLOBAL void rho_file_impl_delete_folder(const char* szFolderPath) {
+    /*
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
+    if (!cls) return;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "deleteFolder", "(Ljava/lang/String;)V");
+    if (!mid) return;
+    jhstring objFolderPath = rho_cast<jhstring>(szFolderPath);
+    env->CallStaticVoidMethod(cls, mid, objFolderPath.get());
+     */
+    
+}
+
+RHO_GLOBAL void rho_file_impl_copy_folders_content_to_another_folder(const char* szSrcFolderPath, const char* szDstFolderPath) {
+    /*
+    JNIEnv *env = jnienv();
+    jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
+    if (!cls) return;
+    jmethodID mid = getJNIClassStaticMethod(env, cls, "copyFoldersContentToAnotherFolder", "(Ljava/lang/String;Ljava/lang/String;)V");
+    if (!mid) return;
+    jhstring objSrcFolderPath = rho_cast<jhstring>(szSrcFolderPath);
+    jhstring objDstFolderPath = rho_cast<jhstring>(szDstFolderPath);
+    env->CallStaticVoidMethod(cls, mid, objSrcFolderPath.get(), objDstFolderPath.get());
+     */
+}
+
+RHO_GLOBAL void rho_platform_restart_application() {
+
+}
+
 RHO_GLOBAL VALUE rho_sys_makephonecall(const char* callname, int nparams, char** param_names, char** param_values)
 {
     // TODO:

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

@@ -50,15 +50,25 @@ Out date_cast(In value);
 template <>
 jobject date_cast<jobject, VALUE>(VALUE rDate)
 {
-    if (NIL_P(rDate))
+    RHO_TRACE("dateFromRuby");
+
+    if (NIL_P(rDate)) {
+        RHO_TRACE("dateFromRuby - NIL object");
         return NULL;
+    }
 
-    RHO_TRACE("dateFromRuby (1)");
+    RHO_TRACE("dateFromRuby - check for string type");
     if (TYPE(rDate) == T_STRING)
     {
-        RHO_TRACE("dateFromRuby (1.1)");
+        RHO_TRACE("dateFromRuby - converting from string");
+
+        if (strlen(RSTRING_PTR(rDate)) == 0) {
+            RHO_TRACE("dateFromRuby - empty string");
+            return NULL;
+        }
+
         rDate = rb_funcall(rb_cTime, rb_intern("parse"), 1, rDate);
-        RHO_TRACE("dateFromRuby (1.2)");
+        RHO_TRACE("dateFromRuby - converted to ruby date");
     }
     VALUE cDate = rb_class_of(rDate);
     if (!rb_equal(cDate, rb_cTime))
@@ -141,6 +151,8 @@ static jfieldID fidNotes;
 static jfieldID fidPrivacy;
 static jfieldID fidFrequency;
 static jfieldID fidInterval;
+static jfieldID fidRecurrenceEnd;
+static jfieldID fidRecurrenceTimes;
 
 static bool init_event_stuff(JNIEnv *env)
 {
@@ -170,6 +182,10 @@ static bool init_event_stuff(JNIEnv *env)
     if (!fidFrequency) return false;
     fidInterval = getJNIClassField(env, clsEvent, "interval", "I");
     if (!fidInterval) return false;
+    fidRecurrenceEnd = getJNIClassField(env, clsEvent, "recurrenceEnd", "Ljava/util/Date;");
+    if (!fidRecurrenceEnd) return false;
+    fidRecurrenceTimes = getJNIClassField(env, clsEvent, "recurrenceTimes", "I");
+    if (!fidRecurrenceTimes) return false;
 
     initialized = true;
     return true;
@@ -240,7 +256,7 @@ jobject event_cast<jobject, VALUE>(VALUE rEvent)
         env->SetObjectField(jEvent, fidNotes, rho_cast<jhstring>(RSTRING_PTR(rNotes)).get());
     }
 
-    RHO_TRACE("eventFromRuby (10)");
+    RHO_TRACE("eventFromRuby privacy");
     VALUE rPrivacy = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_PRIVACY));
     if (!NIL_P(rPrivacy))
     {
@@ -248,7 +264,7 @@ jobject event_cast<jobject, VALUE>(VALUE rEvent)
         env->SetObjectField(jEvent, fidPrivacy, rho_cast<jhstring>(RSTRING_PTR(rPrivacy)).get());
     }
 
-    RHO_TRACE("eventFromRuby (11)");
+    RHO_TRACE("eventFromRuby recurrence");
     VALUE rRecurrence = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_RECURRENCE));
     if (!NIL_P(rRecurrence)) {
         Check_Type(rRecurrence, T_HASH);
@@ -269,6 +285,19 @@ jobject event_cast<jobject, VALUE>(VALUE rEvent)
         rInterval = rb_funcall(rInterval, rb_intern("to_i"), 0);
         int interval = NUM2INT(rInterval);
         env->SetIntField(jEvent, fidInterval, interval);
+        RAWTRACE1("eventFromRuby recurrence interval: %d", interval);
+
+        VALUE rUntilDate = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_END));
+        if (!NIL_P(rUntilDate))
+        {
+            env->SetObjectField(jEvent, fidRecurrenceEnd, date_cast<jobject>(rUntilDate));
+            RAWTRACE("eventFromRuby recurrence until date");
+        }
+
+        VALUE rTimes = rb_funcall(rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_COUNT)), rb_intern("to_i"), 0);;
+        int times = NUM2INT(rTimes);
+        env->SetIntField(jEvent, fidRecurrenceTimes, times);
+        RAWTRACE1("eventFromRuby recurrence count: %d", times);
     }
 
     RHO_TRACE("eventFromRuby: return");
@@ -278,48 +307,50 @@ jobject event_cast<jobject, VALUE>(VALUE rEvent)
 template <>
 VALUE event_cast<VALUE, jobject>(jobject jEvent)
 {
+    RHO_TRACE("eventToRuby");
+
     if (!jEvent)
         return Qnil;
 
-    RHO_TRACE("eventToRuby (1)");
+    RHO_TRACE("eventToRuby init JNI");
     JNIEnv *env = jnienv();
     if (!init_event_stuff(env))
     {
-        RHO_TRACE("eventToRuby (1.1)");
+        RHO_TRACE("eventToRuby failed to init JNI");
         return Qnil;
     }
 
-    RHO_TRACE("eventToRuby (2)");
+    RHO_TRACE("eventToRuby alloc event hash");
     VALUE rEvent = rb_hash_new();
 
-    RHO_TRACE("eventToRuby (3)");
+    RHO_TRACE("eventToRuby get event id");
     jstring jId = (jstring)env->GetObjectField(jEvent, fidId);
     std::string s = rho_cast<std::string>(env, jId);
     env->DeleteLocalRef(jId);
     rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_ID), rb_str_new2(s.c_str()));
 
-    RHO_TRACE("eventToRuby (4)");
+    RHO_TRACE("eventToRuby get title");
     jstring jTitle = (jstring)env->GetObjectField(jEvent, fidTitle);
     s = rho_cast<std::string>(env, jTitle);
     env->DeleteLocalRef(jTitle);
     rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_TITLE), rb_str_new2(s.c_str()));
 
-    RHO_TRACE("eventToRuby (5)");
+    RHO_TRACE("eventToRuby get start date");
     jobject jStartDate = env->GetObjectField(jEvent, fidStartDate);
     rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_START_DATE), date_cast<VALUE>(jStartDate));
     env->DeleteLocalRef(jStartDate);
 
-    RHO_TRACE("eventToRuby (6)");
+    RHO_TRACE("eventToRuby get end date");
     jobject jEndDate = env->GetObjectField(jEvent, fidEndDate);
     rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_END_DATE), date_cast<VALUE>(jEndDate));
     env->DeleteLocalRef(jEndDate);
 
-    RHO_TRACE("eventToRuby (7)");
+    RHO_TRACE("eventToRuby get last modified date");
     jobject jLastModified = env->GetObjectField(jEvent, fidLastModified);
     rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_LAST_MODIFIED), date_cast<VALUE>(jLastModified));
     env->DeleteLocalRef(jLastModified);
 
-    RHO_TRACE("eventToRuby (8)");
+    RHO_TRACE("eventToRuby get location");
     jstring jLocation = (jstring)env->GetObjectField(jEvent, fidLocation);
     if (jLocation)
     {
@@ -328,7 +359,7 @@ VALUE event_cast<VALUE, jobject>(jobject jEvent)
         rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_LOCATION), rb_str_new2(s.c_str()));
     }
 
-    RHO_TRACE("eventToRuby (9)");
+    RHO_TRACE("eventToRuby get notes");
     jstring jNotes = (jstring)env->GetObjectField(jEvent, fidNotes);
     if (jNotes)
     {
@@ -337,7 +368,7 @@ VALUE event_cast<VALUE, jobject>(jobject jEvent)
         rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_NOTES), rb_str_new2(s.c_str()));
     }
 
-    RHO_TRACE("eventToRuby (10)");
+    RHO_TRACE("eventToRuby get privacy");
     jstring jPrivacy = (jstring)env->GetObjectField(jEvent, fidPrivacy);
     if (jPrivacy)
     {
@@ -346,22 +377,24 @@ VALUE event_cast<VALUE, jobject>(jobject jEvent)
         rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_PRIVACY), rb_str_new2(s.c_str()));
     }
 
-    RHO_TRACE("eventToRuby (11)");
+    RHO_TRACE("eventToRuby frequency");
     jstring jFrequency = (jstring)env->GetObjectField(jEvent, fidFrequency);
-    if (jFrequency)
+    if(jFrequency)
     {
+        RHO_TRACE("eventToRuby parse frequency");
+
         VALUE rRecurrence = rb_hash_new();
 
         jboolean isCopy;
         const char* str = env->GetStringUTFChars (jFrequency, &isCopy);
-        if (   strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_DAILY) == 0
-        	|| strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY) == 0
-        	|| strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY) == 0
-        	|| strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_YEARLY) == 0)
+        if(strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_DAILY) == 0
+            || strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY) == 0
+            || strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY) == 0
+            || strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_YEARLY) == 0)
         {
-        	s = rho_cast<std::string>(env, jFrequency);
+            s = rho_cast<std::string>(env, jFrequency);
         } else {
-        	s = "undefined";
+            s = "undefined";
             // rb_raise(rb_eArgError, "Wrong recurrence frequency: %s", frequency);
         }
         if (isCopy == JNI_TRUE) {
@@ -373,6 +406,15 @@ VALUE event_cast<VALUE, jobject>(jobject jEvent)
         jint jInterval = (jint)env->GetIntField(jEvent, fidInterval);
         rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_INTERVAL), INT2FIX((int)jInterval));
 
+        jhobject jhUntil = env->GetObjectField(jEvent, fidRecurrenceEnd);
+        if(jhUntil.get())
+        {
+            rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_END), date_cast<VALUE>(jhUntil.get()));
+        }
+
+        jint jCount = env->GetIntField(jEvent, fidRecurrenceTimes);
+        rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_COUNT), INT2FIX((int)jCount));
+
         rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_RECURRENCE), rRecurrence);
     }
 
@@ -382,8 +424,10 @@ VALUE event_cast<VALUE, jobject>(jobject jEvent)
 
 RHO_GLOBAL VALUE event_fetch(VALUE rParams)
 {
+    RHO_TRACE("event_fetch");
+
     JNIEnv *env = jnienv();
-    jclass cls = getJNIClass(RHODES_JAVA_CLASS_EVENT_STORE);
+    jclass& cls = getJNIClass(RHODES_JAVA_CLASS_EVENT_STORE);
     if (!cls) return Qnil;
     jmethodID mid = getJNIClassStaticMethod(env, cls, "fetch", "(Ljava/util/Date;Ljava/util/Date;Z)Ljava/lang/Object;");
     if (!mid) return Qnil;
@@ -392,17 +436,17 @@ RHO_GLOBAL VALUE event_fetch(VALUE rParams)
     VALUE end_date = rb_hash_aref(rParams, rb_str_new2(RUBY_EV_END_DATE));
     VALUE include_repeating = rb_hash_aref(rParams, rb_str_new2(RUBY_FETCH_include_repeating));
 
-    RHO_TRACE("event_fetch (1)");
+    RHO_TRACE("event_fetch: start date");
     jobject jStartDate = date_cast<jobject>(start_date);
-    RHO_TRACE("event_fetch (2)");
+    RHO_TRACE("event_fetch: end date");
     jobject jEndDate = date_cast<jobject>(end_date);
-    RHO_TRACE("event_fetch (3)");
+    RHO_TRACE("event_fetch: EventStore.fetch()");
     jobject jRet = env->CallStaticObjectMethod(cls, mid, jStartDate, jEndDate, (jboolean)rho_ruby_get_bool(include_repeating));
-    RHO_TRACE("event_fetch (4)");
+    RHO_TRACE("event_fetch: release java references");
     env->DeleteLocalRef(jStartDate);
     env->DeleteLocalRef(jEndDate);
 
-    jclass clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
+    jclass& clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
     if (!clsString) return Qnil;
     if (env->IsInstanceOf(jRet, clsString))
     {

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

@@ -136,7 +136,7 @@ void* RhoNativeViewManager::getWebViewObject(int tab_index) {
     JNIEnv *env = jnienv();
     jclass cls = rho_find_class(env, "com/rhomobile/rhodes/nativeview/RhoNativeViewManager");
     if (!cls) return null;
-    jmethodID mid = env->GetStaticMethodID( cls, "getWebViewObject", "(I)Landroid/webkit/WebView;");
+    jmethodID mid = env->GetStaticMethodID( cls, "getWebViewObject", "(I)Lcom/rhomobile/rhodes/webview/WebView;");
     if (!mid) return null;
     return env->CallStaticObjectMethod(cls, mid, tab_index);
 }

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

@@ -106,11 +106,41 @@ static VALUE createHashFromContact(jobject contactObj)
     return contactHash;
 }
 
-RHO_GLOBAL VALUE getPhonebookRecords(void* pb, int offset, int max_results, rho_param* select_param)
+RHO_GLOBAL VALUE getPhonebookRecords(void* pb, rho_param* params)
 {
-    if (logging_enable) RAWLOG_INFO2("getPhonebookRecords(%d, %d) START", offset, max_results);
+    RAWTRACE("getPhonebookRecords() START");
     jobject phonebookObj = (jobject)pb;
 
+    int offset = 0;
+    int max_results = -1;
+    rho_param* select_param = 0;
+    rho_param* conditions = 0;
+
+    if (params != 0 && params->type == RHO_PARAM_HASH) {
+        for (int i = 0, lim = params->v.hash->size; i < lim; ++i) {
+            std::string key = params->v.hash->name[i];
+            rho_param* value = params->v.hash->value[i];
+
+            if (key.compare("offset") == 0) {
+                RAWTRACE("'offset' parameter found");
+                if (value->type == RHO_PARAM_STRING) {
+                    RAWTRACE1("'offset' parameter is string: %s", value->v.string);
+                    sscanf(value->v.string, "%d", &offset);
+                }
+            } else if (key.compare("per_page") == 0) {
+                RAWTRACE("'per_page' parameter found");
+                if (value->type == RHO_PARAM_STRING) {
+                    RAWTRACE1("'per_page' parameter is string: %s", value->v.string);
+                    sscanf(value->v.string, "%d", &max_results);
+                }
+            } else if (key.compare("select") == 0) {
+                select_param = value;
+            } else if (key.compare("conditions") == 0) {
+                conditions = value;
+            }
+        }
+    }
+
     JNIEnv *env = jnienv();
 
     jclass phonebookCls = getJNIClass(RHODES_JAVA_CLASS_PHONEBOOK);
@@ -118,7 +148,7 @@ RHO_GLOBAL VALUE getPhonebookRecords(void* pb, int offset, int max_results, rho_
     jclass contactCls = getJNIClass(RHODES_JAVA_CLASS_CONTACT);
     if (!contactCls) return Qnil;
 
-    jmethodID queryMID = getJNIClassMethod(env, phonebookCls, "queryContacts", "(IILjava/util/List;)V");
+    jmethodID queryMID = getJNIClassMethod(env, phonebookCls, "queryContacts", "(IILjava/util/List;Ljava/util/Map;)V");
     if (!queryMID) return Qnil;
 
     jmethodID phonebookMoveToBeginMID = getJNIClassMethod(env, phonebookCls, "moveToBegin", "()V");
@@ -138,8 +168,14 @@ RHO_GLOBAL VALUE getPhonebookRecords(void* pb, int offset, int max_results, rho_
         RAWLOG_INFO("Converting 'select_param'.");
         selectObj = RhoValueConverter(env).createObject(select_param);
     }
-    env->CallVoidMethod(phonebookObj, queryMID, offset, max_results, selectObj);
+    jobject conditionsObj = NULL;
+    if (conditions) {
+        RAWLOG_INFO("Converting 'conditions'.");
+        conditionsObj = RhoValueConverter(env).createObject(conditions);
+    }
+    env->CallVoidMethod(phonebookObj, queryMID, offset, max_results, selectObj, conditionsObj);
     env->DeleteLocalRef(selectObj);
+    env->DeleteLocalRef(conditionsObj);
     env->CallVoidMethod(phonebookObj, phonebookMoveToBeginMID);
 
     VALUE valGc = rho_ruby_disable_gc();
@@ -165,20 +201,48 @@ RHO_GLOBAL VALUE getPhonebookRecords(void* pb, int offset, int max_results, rho_
     return hash;
 }
 
-RHO_GLOBAL int getPhonebookRecordCount(void* pb, int offset, int max_results)
+RHO_GLOBAL int getPhonebookRecordCount(void* pb, rho_param* params)
 {
-    if (logging_enable) RAWLOG_INFO2("getPhonebookRecordCount(%d, %d) START", offset, max_results);
+    RAWTRACE("getPhonebookRecordCount() START");
     jobject phonebookObj = static_cast<jobject>(pb);
 
+    int offset = 0;
+    int max_results = -1;
+    rho_param* conditions = 0;
+
+    if (params != 0 && params->type == RHO_PARAM_HASH) {
+        for (int i = 0, lim = params->v.hash->size; i < lim; ++i) {
+            std::string key = params->v.hash->name[i];
+            rho_param* value = params->v.hash->value[i];
+
+            if (key.compare("offset") == 0) {
+                if (value->type == RHO_PARAM_STRING) {
+                    sscanf(value->v.string, "%d", &offset);
+                }
+            } else if (key.compare("per_page") == 0) {
+                if (value->type == RHO_PARAM_STRING) {
+                    sscanf(value->v.string, "%d", &max_results);
+                }
+            } else if (key.compare("conditions") == 0) {
+                conditions = value;
+            }
+        }
+    }
     JNIEnv *env = jnienv();
 
     jclass phonebookCls = getJNIClass(RHODES_JAVA_CLASS_PHONEBOOK);
     if (!phonebookCls) return 0;
 
-    jmethodID queryMID = getJNIClassMethod(env, phonebookCls, "queryContactCount", "(II)I");
+    jmethodID queryMID = getJNIClassMethod(env, phonebookCls, "queryContactCount", "(IILjava/util/Map;)I");
     if (!queryMID) return 0;
 
-    int contactCount =  env->CallIntMethod(phonebookObj, queryMID, offset, max_results);
+    jobject conditionsObj = NULL;
+    if (conditions) {
+        RAWLOG_INFO("Converting 'conditions'.");
+        conditionsObj = RhoValueConverter(env).createObject(conditions);
+    }
+    int contactCount =  env->CallIntMethod(phonebookObj, queryMID, offset, max_results, conditionsObj);
+    env->DeleteLocalRef(conditionsObj);
 
     if (logging_enable) RAWLOG_INFO("getPhonebookRecordCount() FINISH");
     return contactCount;
@@ -187,7 +251,7 @@ RHO_GLOBAL int getPhonebookRecordCount(void* pb, int offset, int max_results)
 RHO_GLOBAL VALUE getallPhonebookRecords(void* pb)
 {
     if (logging_enable) RAWLOG_INFO("getallPhonebookRecords() START");
-    VALUE res = getPhonebookRecords(pb, 0, -1, 0);
+    VALUE res = getPhonebookRecords(pb, 0);
     if (logging_enable) RAWLOG_INFO("getallPhonebookRecords() FINISH");
     return res;
 }