rhoconnect-client 5.5.0

data/rhoconnect-client/Java/RhoConnect/jni/src/RhoConnectJniModel.cpp

@@ -0,0 +1,332 @@
+/*------------------------------------------------------------------------
+* (The MIT License)
+* 
+* Copyright (c) 2008-2011 Rhomobile, Inc.
+* 
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+* 
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+* 
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+* 
+* http://rhomobile.com
+
+* Copyright (c) 2011-2016 Symbol Technologies, Inc.
+* 
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+* 
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+* 
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+* 
+* http://symbol.com
+*------------------------------------------------------------------------*/
+
+#include "rhodes/JNIRhodes.h"
+#include "sync/SyncThread.h"
+#include "RhoConnectClient/RhoConnectClient.h"
+#include "logging/RhoLog.h"
+
+#include "com_rhomobile_rhoconnect_RhomModel.h"
+
+#include "RhoConnectJniNotify.h"
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "RhomModelJNI"
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhoconnect_RhomModel_init
+  (JNIEnv * env, jobject jmodel)
+{
+    static jclass clsmodel = getJNIClass(RHOCONNECT_JAVA_CLASS_RHOMMODEL);
+    if (!clsmodel) return;
+
+    static jmethodID midmodeltype = getJNIClassMethod(env, clsmodel, "setModelType", "(I)V");
+    if (!midmodeltype) return;
+    static jmethodID midsynctype = getJNIClassMethod(env, clsmodel, "setSyncType", "(I)V");
+    if (!midsynctype) return;
+    static jmethodID midsyncpri = getJNIClassMethod(env, clsmodel, "setSyncPriority", "(I)V");
+    if (!midsyncpri) return;
+    static jmethodID midpart = getJNIClassMethod(env, clsmodel, "setPartition", "(Ljava/lang/String;)V");
+    if (!midpart) return;
+
+    RHOM_MODEL model;
+    rho_connectclient_initmodel(&model);
+
+    env->CallVoidMethod(jmodel, midmodeltype, model.type);
+    env->CallVoidMethod(jmodel, midsynctype, model.sync_type);
+    env->CallVoidMethod(jmodel, midsyncpri, model.sync_priority);
+    env->CallVoidMethod(jmodel, midpart, rho_cast<jhstring>(env, model.partition).get());
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhoconnect_RhomModel_syncByName
+  (JNIEnv * env, jclass, jstring jname)
+{
+    std::string name = rho_cast<std::string>(env, jname);
+
+    LOG(INFO) + "Syncing model: " + name;
+
+    char* res = reinterpret_cast<char*>(rho_sync_doSyncSourceByName(name.c_str()));
+    jhobject jhNotify = rho::connect_jni::rhoconnect_jni_parsenotify(env, res);
+    rho_sync_free_string(res);
+    return jhNotify.release();
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+int java_map_inserter(const char* key, const char* val, void* pThis)
+{
+    JNIEnv * env = jnienv();
+    jobject jMap = reinterpret_cast<jobject>(pThis);
+
+    jclass& jMapClass = getJNIClass(RHODES_JAVA_CLASS_MAP);
+    if (!jMapClass) return 0;
+
+    static jmethodID midPut = getJNIClassMethod(env, jMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+    if (!midPut) return 0;
+
+    jhstring jhKey = rho_cast<jhstring>(env, key);
+    jhstring jhVal = rho_cast<jhstring>(env, val);
+    env->CallObjectMethod(jMap, midPut, jhKey.get(), jhVal.get());
+
+    return 1;
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+unsigned long rhoconnect_jni_make_object_hash(JNIEnv * env, jobjectArray jKeys, jobjectArray jVals)
+{
+    unsigned long item = rho_connectclient_hash_create();
+
+    unsigned n = env->GetArrayLength(jKeys);
+    for(unsigned i = 0; i < n; ++i)
+    {
+        jhstring jkey = static_cast<jstring>(env->GetObjectArrayElement(jKeys, i));
+        jhstring jval = static_cast<jstring>(env->GetObjectArrayElement(jVals, i));
+
+        std::string key = rho_cast<std::string>(env, jkey);
+        std::string val = rho_cast<std::string>(env, jval);
+
+        rho_connectclient_hash_put(item, key.c_str(), val.c_str());
+    }
+    return item;
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhoconnect_RhomModel_createByName
+  (JNIEnv * env, jclass, jstring jModelName, jobjectArray jKeys, jobjectArray jVals)
+{
+    std::string name = rho_cast<std::string>(env, jModelName);
+    LOG(TRACE) + "createByName: " + name;
+
+    unsigned long item = rhoconnect_jni_make_object_hash(env, jKeys, jVals);
+
+    rho_connectclient_create_object(name.c_str(), item);
+    
+    static jclass jMapClass = getJNIClass(RHODES_JAVA_CLASS_HASHMAP);
+    if (!jMapClass) return 0;
+
+    static jmethodID midHashMap = getJNIClassMethod(env, jMapClass, "<init>", "()V");
+    if (!midHashMap) return 0;
+
+    jobject jMap = env->NewObject(jMapClass, midHashMap);
+    rho_connectclient_hash_enumerate(item, java_map_inserter, jMap);
+    rho_connectclient_hash_delete(item);
+    return jMap;
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhoconnect_RhomModel_findByName
+  (JNIEnv * env, jclass, jstring jModelName, jstring jItemId)
+{
+    std::string modelName = rho_cast<std::string>(env, jModelName);
+    std::string itemId = rho_cast<std::string>(env, jItemId);
+
+    unsigned long item = rho_connectclient_find(modelName.c_str(), itemId.c_str());
+    if (item == 0) return NULL;
+
+    static jclass jMapClass = getJNIClass(RHODES_JAVA_CLASS_HASHMAP);
+    if (!jMapClass) return 0;
+
+    static jmethodID midHashMap = getJNIClassMethod(env, jMapClass, "<init>", "()V");
+    if (!midHashMap) return 0;
+
+    jobject jMap = env->NewObject(jMapClass, midHashMap);
+    rho_connectclient_hash_enumerate(item, java_map_inserter, jMap);
+    return jMap;
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhoconnect_RhomModel_saveByName
+  (JNIEnv * env, jclass, jstring jModelName, jobjectArray jKeys, jobjectArray jVals)
+{
+    std::string name = rho_cast<std::string>(env, jModelName);
+
+    LOG(TRACE) + "saveByName: " + name;
+
+    unsigned long item = rhoconnect_jni_make_object_hash(env, jKeys, jVals);
+
+    rho_connectclient_save(name.c_str(), item);
+    rho_connectclient_hash_delete(item);
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhoconnect_RhomModel_destroyByName
+  (JNIEnv * env, jclass, jstring jModelName, jobjectArray jKeys, jobjectArray jVals)
+{
+    std::string name = rho_cast<std::string>(env, jModelName);
+    LOG(TRACE) + "destroyByName: " + name;
+    
+    unsigned long item = rhoconnect_jni_make_object_hash(env, jKeys, jVals);
+
+    rho_connectclient_itemdestroy(name.c_str(), item);
+    rho_connectclient_hash_delete(item);
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhoconnect_RhomModel_startBulkUpdateByName
+  (JNIEnv * env, jclass, jstring jModelName)
+{
+    std::string modelName = rho_cast<std::string>(env, jModelName);
+    rho_connectclient_start_bulkupdate(modelName.c_str());
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL void JNICALL Java_com_rhomobile_rhoconnect_RhomModel_stopBulkUpdateByName
+  (JNIEnv * env, jclass, jstring jModelName)
+{
+    std::string modelName = rho_cast<std::string>(env, jModelName);
+    rho_connectclient_stop_bulkupdate(modelName.c_str());
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhoconnect_RhomModel_findFirstByName
+  (JNIEnv * env, jclass, jstring jModelName, jobjectArray jKeys, jobjectArray jVals)
+{
+    std::string name = rho_cast<std::string>(env, jModelName);
+    LOG(TRACE) + "findFirstByName: " + name;
+
+    unsigned long cond = rhoconnect_jni_make_object_hash(env, jKeys, jVals);
+
+    unsigned long item = rho_connectclient_find_first(name.c_str(), cond);
+    rho_connectclient_hash_delete(cond);
+
+    LOG(TRACE) + "Item found: " + item;
+    if (item == 0) return 0;
+
+    static jclass jMapClass = getJNIClass(RHODES_JAVA_CLASS_HASHMAP);
+    if (!jMapClass) return 0;
+
+    static jmethodID midHashMap = getJNIClassMethod(env, jMapClass, "<init>", "()V");
+    if (!midHashMap) return 0;
+
+    jobject jMap = env->NewObject(jMapClass, midHashMap);
+
+    LOG(TRACE) + "Enumerating item: " + item;
+
+    rho_connectclient_hash_enumerate(item, java_map_inserter, jMap);
+    return jMap;
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhoconnect_RhomModel_findAllByName
+  (JNIEnv * env, jclass, jstring jModelName, jobjectArray jKeys, jobjectArray jVals)
+{
+    std::string name = rho_cast<std::string>(env, jModelName);
+
+    LOG(TRACE) + "findFirstByName: " + name;
+
+    unsigned long cond = rhoconnect_jni_make_object_hash(env, jKeys, jVals);
+
+    unsigned long items = rho_connectclient_find_all(name.c_str(), cond);
+    rho_connectclient_hash_delete(cond);
+
+    static jclass jListClass = getJNIClass(RHODES_JAVA_CLASS_ARRAYLIST);
+    if (!jListClass) return 0;
+    static jmethodID midList = getJNIClassMethod(env, jListClass, "<init>", "()V");
+    if (!midList) return 0;
+    static jmethodID midListAdd = getJNIClassMethod(env, jListClass, "add", "(Ljava/lang/Object;)Z");
+    if (!midList) return 0;
+
+    static jclass jMapClass = getJNIClass(RHODES_JAVA_CLASS_HASHMAP);
+    if (!jMapClass) return 0;
+    static jmethodID midHashMap = getJNIClassMethod(env, jMapClass, "<init>", "()V");
+    if (!midHashMap) return 0;
+
+    jobject jList = env->NewObject(jListClass, midList);
+
+    int cnt = rho_connectclient_strhasharray_size(items);
+    for(int i = 0; i < cnt; ++i)
+    {
+        jobject jMap = env->NewObject(jMapClass, midHashMap);
+        rho_connectclient_hash_enumerate(rho_connectclient_strhasharray_get(items, i), java_map_inserter, jMap);
+        env->CallBooleanMethod(jList, midListAdd, jMap);
+        env->DeleteLocalRef(jMap);
+    }
+    return jList;
+}
+//----------------------------------------------------------------------------------------------------------------------
+
+RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhoconnect_RhomModel_findBySqlByName
+  (JNIEnv * env, jclass, jstring jModelName, jstring jQuery, jobjectArray jParams)
+{
+    std::string name = rho_cast<std::string>(env, jModelName);
+
+    LOG(TRACE) + "findBySqlByName: " + name;
+
+    std::string query = rho_cast<std::string>(env, jQuery);
+    std::auto_ptr<rho::Vector<std::string> > params = (jParams != NULL)
+                                                ? rho_cast<std::auto_ptr<rho::Vector<std::string> > >(env, jParams)
+                                                : std::auto_ptr<rho::Vector<std::string> >(0);
+
+    unsigned long items = rho_connectclient_findbysql(name.c_str(), query.c_str(), reinterpret_cast<unsigned long>(params.get()));
+
+    jclass& jListClass = getJNIClass(RHODES_JAVA_CLASS_ARRAYLIST);
+    if (!jListClass) return 0;
+    static jmethodID midList = getJNIClassMethod(env, jListClass, "<init>", "()V");
+    if (!midList) return 0;
+    static jmethodID midListAdd = getJNIClassMethod(env, jListClass, "add", "(Ljava/lang/Object;)Z");
+    if (!midList) return 0;
+
+    jclass& jMapClass = getJNIClass(RHODES_JAVA_CLASS_HASHMAP);
+    if (!jMapClass) return 0;
+    static jmethodID midHashMap = getJNIClassMethod(env, jMapClass, "<init>", "()V");
+    if (!midHashMap) return 0;
+
+    jobject jList = env->NewObject(jListClass, midList);
+
+    int cnt = rho_connectclient_strhasharray_size(items);
+    for(int i = 0; i < cnt; ++i)
+    {
+        jobject jMap = env->NewObject(jMapClass, midHashMap);
+        rho_connectclient_hash_enumerate(rho_connectclient_strhasharray_get(items, i), java_map_inserter, jMap);
+        env->CallBooleanMethod(jList, midListAdd, jMap);
+        env->DeleteLocalRef(jMap);
+    }
+    return jList;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+

data/rhoconnect-client/Java/RhoConnect/jni/src/RhoConnectJniNotify.cpp

@@ -0,0 +1,223 @@
+/*------------------------------------------------------------------------
+* (The MIT License)
+* 
+* Copyright (c) 2008-2011 Rhomobile, Inc.
+* 
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+* 
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+* 
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+* 
+* http://rhomobile.com
+
+* Copyright (c) 2011-2016 Symbol Technologies, Inc.
+* 
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+* 
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+* 
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+* 
+* http://symbol.com
+*------------------------------------------------------------------------*/
+
+#include "rhodes/JNIRhodes.h"
+#include "sync/SyncThread.h"
+#include "RhoConnectClient/RhoConnectClient.h"
+#include "logging/RhoLog.h"
+
+#include "RhoConnectJniNotify.h"
+
+namespace rho { namespace connect_jni {
+
+jobject rhoconnect_jni_parsenotify(JNIEnv * env, const char* res)
+{
+    LOG(TRACE) + "rhoconnect_jni_parsenotify: " + res;
+    
+    RHO_CONNECT_NOTIFY notify;
+    memset(&notify, 0, sizeof(notify));
+
+    rho_connectclient_parsenotify(res, &notify);
+
+    static jclass clsNotify = getJNIClass(RHOCONNECT_JAVA_CLASS_NOTIFY);
+    if (!clsNotify) return NULL;
+
+    static jmethodID midNotify = getJNIClassMethod(env, clsNotify, "<init>", "()V");
+    if (!midNotify) return NULL;
+    static jfieldID fidTotalCount = getJNIClassField(env, clsNotify, "mTotalCount", "I");
+    if (!fidTotalCount) return NULL;
+    static jfieldID fidProcCount = getJNIClassField(env, clsNotify, "mProcessedCount", "I");
+    if (!fidProcCount) return NULL;
+    static jfieldID fidCumulativeCount = getJNIClassField(env, clsNotify, "mCumulativeCount", "I");
+    if (!fidCumulativeCount) return NULL;
+    static jfieldID fidSrcId = getJNIClassField(env, clsNotify, "mSourceId", "I");
+    if (!fidSrcId) return NULL;
+    static jfieldID fidErrorCode = getJNIClassField(env, clsNotify, "mErrorCode", "I");
+    if (!fidErrorCode) return NULL;
+    static jfieldID fidSrcName = getJNIClassField(env, clsNotify, "mSourceName", "Ljava/lang/String;");
+    if (!fidSrcName) return NULL;
+    static jfieldID fidStatus = getJNIClassField(env, clsNotify, "mStatus", "Ljava/lang/String;");
+    if (!fidStatus) return NULL;
+    static jfieldID fidSyncType = getJNIClassField(env, clsNotify, "mSyncType", "Ljava/lang/String;");
+    if (!fidSyncType) return NULL;
+    static jfieldID fidErrMsg = getJNIClassField(env, clsNotify, "mErrorMessage", "Ljava/lang/String;");
+    if (!fidErrMsg) return NULL;
+    static jfieldID fidParams = getJNIClassField(env, clsNotify, "mParams", "Ljava/lang/String;");
+    if (!fidParams) return NULL;
+
+    jobject jNotify = env->NewObject(clsNotify, midNotify);
+    if (!jNotify) return NULL;
+
+    env->SetIntField(jNotify, fidTotalCount, notify.total_count);
+    env->SetIntField(jNotify, fidProcCount, notify.processed_count);
+    env->SetIntField(jNotify, fidCumulativeCount, notify.cumulative_count);
+    env->SetIntField(jNotify, fidSrcId, notify.source_id);
+    env->SetIntField(jNotify, fidErrorCode, notify.error_code);
+
+    jhstring jhSrcName = rho_cast<jhstring>(env, notify.source_name);
+    jhstring jhStatus = rho_cast<jhstring>(env, notify.status);
+    jhstring jhSyncType = rho_cast<jhstring>(env, notify.sync_type);
+    jhstring jhErrMsg = rho_cast<jhstring>(env, notify.error_message);
+    jhstring jhParams = rho_cast<jhstring>(env, notify.callback_params);
+
+    env->SetObjectField(jNotify, fidSrcName, jhSrcName.get());
+    env->SetObjectField(jNotify, fidStatus, jhStatus.get());
+    env->SetObjectField(jNotify, fidSyncType, jhSyncType.get());
+    env->SetObjectField(jNotify, fidErrMsg, jhErrMsg.get());
+    env->SetObjectField(jNotify, fidParams, jhParams.get());
+
+    rho_connectclient_free_syncnotify(&notify);
+
+    return jNotify;
+
+}
+//----------------------------------------------------------------------------------------------------------------------
+void rhoconnect_jni_fill_objectnotify(JNIEnv * env, jobject jNotify, int cnt, const char* const * objects, int* src_ids,
+                                      jfieldID fidObjects, jfieldID fidSrcIds)
+{
+    static jclass clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
+    if (!clsString) return;
+
+    LOG(TRACE) + "rhoconnect_jni_fill_objectnotify: cnt: " + cnt + ", Java notify reference: " + (int)jNotify;
+
+    if(cnt > 0)
+    {
+        jobjectArray jObjects = env->NewObjectArray(cnt, clsString, NULL);
+        if (!jObjects) return;
+        jintArray jSrcIds = env->NewIntArray(cnt);
+        if (!jSrcIds) return;
+
+        for(int i = 0; i < cnt; ++i)
+        {
+            jhstring jhObject = rho_cast<jhstring>(env, objects[i]);
+            env->SetObjectArrayElement(jObjects, i, jhObject.release());
+        }
+        env->SetIntArrayRegion(jSrcIds, 0, cnt, src_ids);
+
+        env->SetObjectField(jNotify, fidObjects, jObjects);
+        env->SetObjectField(jNotify, fidSrcIds, jSrcIds);
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+jobject rhoconnect_jni_parseobjectnotify(JNIEnv * env, const char* res)
+{
+    LOG(TRACE) + "rhoconnect_jni_parseobjectnotify: " + res;
+    
+    RHO_CONNECT_OBJECT_NOTIFY notify;
+    memset(&notify, 0, sizeof(notify));
+
+    rho_connectclient_parse_objectnotify(res, &notify);
+
+    static jclass clsNotify = getJNIClass(RHOCONNECT_JAVA_CLASS_OBJECTNOTIFY);
+    if (!clsNotify) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify class";
+        return NULL;
+    }
+    static jmethodID midNotify = getJNIClassMethod(env, clsNotify, "<init>", "()V");
+    if (!midNotify) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify constructor method id";
+        return NULL;
+    }
+    static jfieldID fidDeletedObjects = getJNIClassField(env, clsNotify, "mDeletedObjects", "[Ljava/lang/String;");
+    if (!fidDeletedObjects) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify.mDeletedObjects field id";
+        return NULL;
+    }
+    static jfieldID fidUpdatedObjects = getJNIClassField(env, clsNotify, "mUpdatedObjects", "[Ljava/lang/String;");
+    if (!fidUpdatedObjects) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify.mUpdatedObjects field id";
+        return NULL;
+    }
+    static jfieldID fidCreatedObjects = getJNIClassField(env, clsNotify, "mCreatedObjects", "[Ljava/lang/String;");
+    if (!fidCreatedObjects) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify.mCreatedObjects field id";
+        return NULL;
+    }
+    static jfieldID fidDeletedIds = getJNIClassField(env, clsNotify, "mDeletedSrcIds", "[I");
+    if (!fidDeletedIds) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify.mDeletedSrcIds field id";
+        return NULL;
+    }
+    static jfieldID fidUpdatedIds = getJNIClassField(env, clsNotify, "mUpdatedSrcIds", "[I");
+    if (!fidUpdatedIds) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify.mUpdatedSrcIds field id";
+        return NULL;
+    }
+    static jfieldID fidCreatedIds = getJNIClassField(env, clsNotify, "mCreatedSrcIds", "[I");
+    if (!fidCreatedIds) {
+        LOG(ERROR) + "Cannot get RhoConnectObjectNotify.mCreatedSrcIds field id";
+        return NULL;
+    }
+
+    jobject jNotify = env->NewObject(clsNotify, midNotify);
+    if (!jNotify) {
+        LOG(ERROR) + "Cannot create RhoConnectObjectNotify instance";
+        return NULL;
+    }
+
+    rhoconnect_jni_fill_objectnotify(env, jNotify, notify.deleted_count,
+                                     notify.deleted_objects, notify.deleted_source_ids,
+                                     fidDeletedObjects, fidDeletedIds);
+
+    rhoconnect_jni_fill_objectnotify(env, jNotify, notify.updated_count,
+                                     notify.updated_objects, notify.updated_source_ids,
+                                     fidUpdatedObjects, fidUpdatedIds);
+
+    rhoconnect_jni_fill_objectnotify(env, jNotify, notify.created_count,
+                                     notify.created_objects, notify.created_source_ids,
+                                     fidCreatedObjects, fidCreatedIds);
+
+    rho_connectclient_free_sync_objectnotify(&notify);
+
+    LOG(TRACE) + "Returning Java RhoConnectObjectNotify reference: " + (int)jNotify;
+    return jNotify;
+}
+
+}}