rhodes 2.0.3 → 2.1.0

data/platform/shared/SyncClient/SyncClient.cpp

@@ -0,0 +1,860 @@
+#include "SyncClient.h"
+
+//#include "stdafx.h"
+
+#include "common/RhodesAppBase.h"
+#include "sync/SyncThread.h"
+#include "common/RhoFile.h"
+#include "common/Tokenizer.h"
+#include "common/RhoConf.h"
+#include "common/RhoTime.h"
+#include "common/RhoAppAdapter.h"
+#include "net/URI.h"
+
+using namespace rho;
+using namespace rho::common;
+using namespace rho::sync;
+const char* getSyncTypeName( RHOM_SYNC_TYPE sync_type )
+{
+    switch( sync_type)
+    {
+		case RST_INCREMENTAL:
+			return "incremental";
+		case RST_BULK_ONLY:
+			return "bulk_only";
+    }
+	
+    return "none";
+}
+
+void parseSyncNotify(const char* msg, RHO_SYNC_NOTIFY* pNotify);
+String rhom_generate_id();
+
+extern "C" 
+{
+
+void rho_syncclient_initmodel(RHOM_MODEL* model)
+{
+    memset( model, 0, sizeof(RHOM_MODEL) );
+    model->type = RMT_PROPERTY_BAG;
+    model->sync_type = RST_NONE;
+    model->sync_priority = 1000;
+    model->partition = "user";
+}
+
+void rho_syncclient_free_syncnotify(RHO_SYNC_NOTIFY* pNotify)
+{
+    if (!pNotify)
+        return;
+
+    if ( pNotify->source_name != null )
+        free(pNotify->source_name);
+
+    if ( pNotify->status != null )
+        free(pNotify->status);
+
+    if ( pNotify->error_message != null )
+        free(pNotify->error_message);
+
+    if ( pNotify->callback_params != null )
+        free(pNotify->callback_params);
+
+    memset( pNotify, 0, sizeof(RHO_SYNC_NOTIFY) );
+}
+
+void rho_syncclient_processmodels(RHOM_MODEL* pModels, int nModels)
+{
+    db::CDBAdapter& oUserDB = db::CDBAdapter::getUserDB();
+    int nStartModelID = 1;
+    {
+        DBResult( res, oUserDB.executeSQL("SELECT MAX(source_id) AS maxid FROM sources"));
+        if ( !res.isEnd() )
+            nStartModelID = res.getIntByIdx(0)+2;
+    }
+
+    for ( int i = 0; i < nModels; i++ )
+    { 
+        RHOM_MODEL& model = pModels[i];
+        DBResult( res, oUserDB.executeSQL("SELECT sync_priority,source_id,partition, sync_type, schema_version, associations, blob_attribs FROM sources WHERE name=?",
+            model.name) );
+
+        if ( !res.isEnd() )
+        {
+            oUserDB.executeSQL("UPDATE sources SET sync_priority=?, sync_type=?, partition=?, schema_version=?, associations=?, blob_attribs=? WHERE name=?",
+                model.sync_priority, getSyncTypeName(model.sync_type), model.partition, "", "", "", model.name );
+                
+        }else //new model
+        {
+            oUserDB.executeSQL("INSERT INTO sources (source_id,name,sync_priority, sync_type, partition, schema_version, associations, blob_attribs) values (?,?,?,?,?,?,?,?) ",
+                nStartModelID, model.name, model.sync_priority, getSyncTypeName(model.sync_type), model.partition, "", "", "" );
+
+            nStartModelID++;
+        }
+    }
+}
+
+void rho_syncclient_init(RHOM_MODEL* pModels, int nModels)
+{
+    rho_logconf_Init(rho_native_rhopath());
+    CRhodesAppBase::Create( rho_native_rhopath() );
+
+    String strDbPath = rho_native_rhopath();
+
+    //create db and db-files folder
+    CRhoFile::createFolder( (strDbPath + "db/db-files").c_str());
+    CRhoFile::createFolder( (strDbPath + "apps").c_str());
+
+    for( int i = 0; i < nModels; i++ )
+    {
+        RHOM_MODEL& model = pModels[i];
+
+        String strDbPartition = strDbPath + "db/syncdb";
+        strDbPartition += model.partition;
+        strDbPartition += ".sqlite";
+
+        void* pDB = 0;
+        rho_db_open( strDbPartition.c_str(), model.partition, &pDB);
+    }
+
+    //process models
+    rho_syncclient_processmodels(pModels, nModels);
+
+    rho_db_init_attr_manager();
+
+    LOG(INFO) + "Starting sync engine...";
+    CSyncThread::Create(common::rho_impl_createClassFactory());
+
+}
+
+void rho_syncclient_database_full_reset_and_logout()
+{
+    rho_sync_logout();
+
+    db::CDBAdapter& oUserDB = db::CDBAdapter::getUserDB();
+    oUserDB.executeSQL("UPDATE client_info SET reset=1");
+
+    if ( rho_conf_is_property_exists("bulksync_state") )
+        rho_conf_setInt("bulksync_state", 0 );
+
+    oUserDB.executeSQL("UPDATE sources SET token=0");
+
+    Vector<String> arExclude;
+    arExclude.addElement("sources");
+    arExclude.addElement("client_info");
+    db::CDBAdapter::destroy_tables_allpartitions(Vector<String>(), arExclude);
+
+    //TODO: scema_sources
+    //hash_migrate = {}
+    //::Rho::RHO.init_schema_sources(hash_migrate) 
+}
+
+void rho_syncclient_destroy()
+{
+    CSyncThread::Destroy();
+}
+
+bool rhom_method_name_isreserved(const String& strName)
+{
+    static Hashtable<String,int> reserved_names;
+    if ( reserved_names.size() == 0 )
+    {
+        reserved_names.put("object",1);
+        reserved_names.put("source_id",1);
+        reserved_names.put("update_type",1);
+        reserved_names.put("attrib_type",1);
+        reserved_names.put("set_notification",1);
+        reserved_names.put("clear_notification",1);
+    }
+
+    return reserved_names.get(strName) != 0;
+}
+
+void db_insert_into_table( db::CDBAdapter& db, const String& table, Hashtable<String, String>& hashObject, const char* excludes = null)
+{
+    String cols = "";
+    String quests = "";
+    Vector<String> vals;
+
+    for ( Hashtable<String,String>::iterator it = hashObject.begin();  it != hashObject.end(); ++it )
+    {
+        String key = it->first;
+        String val  = it->second;
+
+        if ( excludes && key.compare(excludes) == 0 )
+            continue;
+
+        if (cols.length() > 0)
+        {
+            cols += ',';
+            quests += ',';
+        }
+    
+        cols += key;
+        quests += '?';
+        vals.addElement( val );
+    }
+
+    String query = "insert into " + table + "(" + cols + ") values (" + quests + ")";
+
+    db.executeSQLEx(query.c_str(), vals);
+}
+
+unsigned long rhom_make_object(rho::db::CDBResult& res1, int nSrcID, bool isSchemaSrc)
+{
+    unsigned long item = 0;
+    if ( res1.isEnd() )
+        return item;
+
+    item = rho_syncclient_hash_create();
+    rho_syncclient_hash_put(item, "source_id", convertToStringA(nSrcID).c_str() );
+
+    if (!isSchemaSrc)
+    {
+        for ( ; !res1.isEnd(); res1.next() )
+            rho_syncclient_hash_put(item, res1.getStringByIdx(0).c_str(), res1.getStringByIdx(1).c_str() );
+    }else
+    {
+        for (int i = 0; i < res1.getColCount(); i++ )
+            rho_syncclient_hash_put(item, res1.getColName(i).c_str(), res1.getStringByIdx(i).c_str() );
+    }
+
+    return item;
+}
+
+unsigned long rhom_load_item_by_object(db::CDBAdapter& db, const String& src_name, int nSrcID, const String& szObject, bool isSchemaSrc )
+{
+    unsigned long item = 0;
+
+    if (!isSchemaSrc)
+    {
+        String sql = "SELECT attrib,value FROM object_values WHERE object=? AND source_id=?";
+        DBResult( res1, db.executeSQL(sql.c_str(), szObject, nSrcID) );
+        item = rhom_make_object(res1, nSrcID, isSchemaSrc);
+        if (item)
+            rho_syncclient_hash_put(item, "object", szObject.c_str() );
+    }else
+    {
+        String sql = "SELECT * FROM " + src_name + " WHERE object=? OFFSET 0 LIMIT 1";
+        DBResult( res1, db.executeSQL(sql.c_str(), szObject) );
+        item = rhom_make_object(res1, nSrcID, isSchemaSrc);
+    }
+
+    return item;
+}
+
+unsigned long rho_syncclient_find(const char* szModel,const char* szObject )
+{
+    String src_name = szModel;
+
+    DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return 0;
+    }
+
+    int nSrcID = res.getIntByIdx(0);
+    String db_partition = res.getStringByIdx(1);
+    bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
+    //String tableName = isSchemaSrc ? src_name : "object_values";
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    return rhom_load_item_by_object( db, src_name, nSrcID, szObject, isSchemaSrc);
+}
+
+unsigned long rhom_find(const char* szModel, unsigned long hash, int nCount )
+{
+    String src_name = szModel;
+
+    DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return 0;
+    }
+
+    int nSrcID = res.getIntByIdx(0);
+    String strSrcID = convertToStringA(nSrcID);
+    String db_partition = res.getStringByIdx(1);
+    bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
+    //String tableName = isSchemaSrc ? src_name : "object_values";
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    Hashtable<String, String>& hashCond = *((Hashtable<String, String>*)hash);
+    String sql = "";
+    Vector<String> arValues;
+
+    if (!isSchemaSrc)
+    {
+		if (hashCond.size() == 0) {
+			sql = "SELECT distinct(object) FROM object_values WHERE source_id=?";
+			arValues.addElement(strSrcID);
+		}else
+		{
+			for ( Hashtable<String,String>::iterator it = hashCond.begin();  it != hashCond.end(); ++it )
+			{
+				if ( sql.length() > 0 )
+					sql += "\nINTERSECT\n";
+
+				sql += "SELECT object FROM object_values WHERE attrib=? AND source_id=? AND value=?";
+				arValues.addElement(it->first); 
+				arValues.addElement(strSrcID);
+				arValues.addElement(it->second);
+			}
+		}
+    }else
+    {
+		sql = "SELECT object FROM " + src_name;		
+		if (hashCond.size() != 0) 
+		{
+			sql += " WHERE ";
+			for ( Hashtable<String,String>::iterator it = hashCond.begin();  it != hashCond.end(); ++it )
+			{
+				if (it != hashCond.begin())
+					sql += " AND ";
+				sql += it->first + "=?" ;
+				arValues.addElement(it->second);
+			}
+		}
+    }
+
+    DBResult( res1, db.executeSQLEx(sql.c_str(), arValues ) );
+
+    if ( nCount == 1 )
+    {
+        return isSchemaSrc ? rhom_make_object(res1, nSrcID, isSchemaSrc) :
+                 rhom_load_item_by_object(db, src_name, nSrcID, res1.getStringByIdx(0), isSchemaSrc);
+    }
+
+    unsigned long items = rho_syncclient_strhasharray_create();
+    for ( ; !res1.isEnd(); res1.next() )
+    {
+        rho_syncclient_strhasharray_add(items, 
+            isSchemaSrc ? rhom_make_object(res1, nSrcID, isSchemaSrc) :
+                rhom_load_item_by_object(db, src_name, nSrcID, res1.getStringByIdx(0), isSchemaSrc) );
+    }
+
+    return items;
+}
+
+unsigned long rho_syncclient_find_all(const char* szModel, unsigned long hash )
+{
+    return rhom_find( szModel, hash, -1 );
+}
+
+unsigned long rho_syncclient_find_first(const char* szModel, unsigned long hash )
+{
+    return rhom_find( szModel, hash, 1 );
+}
+
+void rho_syncclient_start_bulkupdate(const char* szModel)
+{
+    String src_name = szModel;
+    DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT partition from sources WHERE name=?", src_name) );
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return;
+    }
+    String db_partition = res.getStringByIdx(0);
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+	
+    db.startTransaction();
+}
+	
+void rho_syncclient_stop_bulkupdate(const char* szModel)
+{
+    String src_name = szModel;
+    DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT partition from sources WHERE name=?", src_name) );
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return;
+    }
+    String db_partition = res.getStringByIdx(0);
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+	
+    db.endTransaction();
+}
+	
+void rho_syncclient_itemdestroy( const char* szModel, unsigned long hash )
+{
+    Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
+    String src_name = szModel;
+
+    String obj = hashObject.get("object");
+    String update_type="delete";
+
+    DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return;
+    }
+
+    int nSrcID = res.getIntByIdx(0);
+    String db_partition = res.getStringByIdx(1);
+    bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
+    bool isSyncSrc = res.getStringByIdx(3).compare("none") != 0;
+    String tableName = isSchemaSrc ? src_name : "object_values";
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    db.startTransaction();
+
+    //save list of attrs
+    unsigned long item = 0;
+    
+    if ( isSchemaSrc )
+    {
+        DBResult( attrsList, db.executeSQL( ("SELECT * FROM " + tableName + " WHERE object=?").c_str(), obj) );
+        if ( !attrsList.isEnd() )
+            item = rhom_make_object(attrsList,nSrcID,isSchemaSrc);
+    }else
+    {
+        DBResult( attrsList, db.executeSQL( ("SELECT attrib, value FROM " + tableName + " WHERE object=? and source_id=?").c_str(), obj, nSrcID) );
+        if ( !attrsList.isEnd() )
+            item = rhom_make_object(attrsList,nSrcID,isSchemaSrc);
+    }
+
+    //first delete the record from viewable list
+    db.executeSQL( ("DELETE FROM " + tableName + " WHERE object=?").c_str(), obj );
+
+    if ( isSyncSrc )
+    {
+        DBResult( resCreateType, db.executeSQL("SELECT update_type FROM changed_values WHERE object=? and update_type=? and sent=?",
+            obj, "create", 0) );
+
+        db.executeSQL("DELETE FROM changed_values WHERE object=? and sent=?", obj, 0);
+
+        if ( resCreateType.isEnd() && item != 0 )
+        {
+            Hashtable<String,String>& hashItem = *((Hashtable<String,String>*)item);
+            for ( Hashtable<String,String>::iterator it = hashItem.begin();  it != hashItem.end(); ++it )
+            {
+                String key = it->first;
+                String val  = it->second;
+
+                if ( rhom_method_name_isreserved(key) )
+                    continue;
+
+                Hashtable<String,String> fields;
+                fields.put("source_id", convertToStringA(nSrcID));
+                fields.put("object", obj);
+                fields.put("attrib", key);
+                fields.put("value", val);
+                fields.put("update_type", update_type);
+
+                db_insert_into_table(db, "changed_values", fields );
+            }
+
+            rho_syncclient_hash_delete(item);
+        }
+    }
+
+    db.endTransaction();
+}
+
+void rho_syncclient_save( const char* szModel, unsigned long hash )
+{
+    Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
+    String src_name = szModel;
+
+    DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return;
+    }
+
+    int nSrcID = res.getIntByIdx(0);
+    String obj = hashObject.get("object");
+
+    String db_partition = res.getStringByIdx(1);
+    bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
+    bool isSyncSrc = res.getStringByIdx(3).compare("none") != 0;
+    String tableName = isSchemaSrc ? src_name : "object_values";
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    db.startTransaction();
+
+    String update_type = "";
+    String sql;
+    Vector<String> arValues;
+    if (isSchemaSrc)
+    {
+        sql = "SELECT object FROM " + tableName + " WHERE object=? LIMIT 1 OFFSET 0";
+        arValues.addElement(obj);
+    }
+    else
+    {
+        sql = "SELECT object FROM " + tableName + " WHERE object=? AND source_id=? LIMIT 1 OFFSET 0";
+        arValues.addElement(obj);
+        arValues.addElement(convertToStringA(nSrcID));
+    }
+    DBResult( res1, db.executeSQLEx(sql.c_str(), arValues ) );
+    if (!res1.isEnd())
+    {
+        if (isSyncSrc)
+        {
+            DBResult( resUpdateType, db.executeSQL( "SELECT update_type FROM changed_values WHERE object=? and source_id=? and sent=?", 
+                obj, nSrcID, 0 ) );
+            if (!resUpdateType.isEnd()) 
+                update_type = resUpdateType.getStringByIdx(0);
+            else
+	            update_type = "update";
+        }else
+            update_type = "update";
+    }
+    else
+    {
+        rho_syncclient_create_object(szModel, hash);
+    }
+
+    if (!res.isEnd())
+    {
+        unsigned long item = rhom_load_item_by_object( db, src_name, nSrcID, obj, isSchemaSrc);
+        Hashtable<String, String>& hashItem = *((Hashtable<String, String>*)item);
+
+        for ( Hashtable<String,String>::iterator it = hashObject.begin();  it != hashObject.end(); ++it )
+        {
+            String key = it->first;
+            String val  = it->second;
+
+            if ( rhom_method_name_isreserved(key) )
+                continue;
+
+            // add rows excluding object, source_id and update_type
+            Hashtable<String,String> fields;
+            fields.put("source_id", convertToStringA(nSrcID));
+            fields.put("object", obj);
+            fields.put("attrib", key);
+            fields.put("value", val);
+            fields.put("update_type", update_type);
+            if ( db::CDBAdapter::getDB(db_partition.c_str()).getAttrMgr().isBlobAttr(nSrcID, key.c_str()) )
+                fields.put( "attrib_type", "blob.file");
+
+            if ( hashItem.containsKey(key) )
+            {
+                bool isModified = hashItem.get(key) != val;
+                if (isModified)
+                {
+                    if (isSyncSrc)
+                    {
+                        DBResult( resUpdateType, db.executeSQL( "SELECT update_type FROM changed_values WHERE object=? and attrib=? and source_id=? and sent=?", 
+                            obj, key, nSrcID, 0 ) );
+                        if (!resUpdateType.isEnd()) 
+                        {
+                            fields.put("update_type", resUpdateType.getStringByIdx(0) );
+                            db.executeSQL( "DELETE FROM changed_values WHERE object=? and attrib=? and source_id=? and sent=?", 
+                                obj, key, nSrcID, 0 );
+                        }
+
+                        db_insert_into_table(db, "changed_values", fields);
+                    }
+                        
+                    if ( isSchemaSrc )
+                        db.executeSQL( (String("UPDATE ") + tableName + " SET " + key + "=? WHERE object=?").c_str(), val, obj );
+                    else
+                        db.executeSQL( "UPDATE object_values SET value=? WHERE object=? and attrib=? and source_id=?", val, obj, key, nSrcID );
+                }
+
+            }else
+            {
+                if (isSyncSrc)
+                    db_insert_into_table(db, "changed_values", fields);
+
+                fields.remove("update_type");
+                fields.remove("attrib_type");
+                
+                if (isSchemaSrc)
+                    db.executeSQL( (String("UPDATE ") + tableName + " SET " + key + "=? WHERE object=?").c_str(), val, obj );
+                else
+                    db_insert_into_table(db, tableName, fields);
+            }
+        }
+    }
+
+    db.endTransaction();
+}
+
+void rho_syncclient_create_object(const char* szModel, unsigned long hash)
+{
+    Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
+    String src_name = szModel;
+
+    DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return;
+    }
+
+    String update_type = "create";
+    int nSrcID = res.getIntByIdx(0);
+    String obj = hashObject.containsKey("object") ? hashObject.get("object") : rhom_generate_id();
+
+    String db_partition = res.getStringByIdx(1);
+    bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
+    bool isSyncSrc = res.getStringByIdx(3).compare("none") != 0;
+    String tableName = isSchemaSrc ? src_name : "object_values";
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    hashObject.put("source_id", convertToStringA(nSrcID));
+    hashObject.put("object", obj);
+
+    db.startTransaction();
+    if ( isSchemaSrc )
+        db_insert_into_table(db, tableName, hashObject, "source_id");
+                        
+    if ( isSyncSrc || !isSchemaSrc )
+    {
+        for ( Hashtable<String,String>::iterator it = hashObject.begin();  it != hashObject.end(); ++it )
+        {
+            String key = it->first;
+            String val  = it->second;
+
+            if ( rhom_method_name_isreserved(key) )
+                continue;
+
+            // add rows excluding object, source_id and update_type
+            Hashtable<String,String> fields;
+            fields.put("source_id", convertToStringA(nSrcID));
+            fields.put("object", obj);
+            fields.put("attrib", key);
+            fields.put("value", val);
+            fields.put("update_type", update_type);
+
+            if ( db::CDBAdapter::getDB(db_partition.c_str()).getAttrMgr().isBlobAttr(nSrcID, key.c_str()) )
+                fields.put( "attrib_type", "blob.file");
+
+            if ( isSyncSrc )
+                db_insert_into_table(db, "changed_values", fields);
+
+            fields.remove("update_type");
+            fields.remove("attrib_type");
+
+            if ( !isSchemaSrc )
+                db_insert_into_table(db, tableName, fields);
+        }
+    }
+                        
+    db.endTransaction();
+}
+
+void rho_syncclient_parsenotify(const char* msg, RHO_SYNC_NOTIFY* pNotify)
+{
+    CTokenizer oTokenizer( msg, "&" );
+    int nLastPos = 0;
+    while (oTokenizer.hasMoreTokens()) 
+    {
+        nLastPos = oTokenizer.getCurPos();
+
+	    String tok = oTokenizer.nextToken();
+	    if (tok.length() == 0)
+		    continue;
+
+        CTokenizer oValueTok( tok, "=" );
+        String name = net::URI::urlDecode(oValueTok.nextToken());
+        String value = net::URI::urlDecode(oValueTok.nextToken());
+
+        if ( name.compare("total_count") == 0)
+            convertFromStringA( value.c_str(), pNotify->total_count );
+        else if ( name.compare("processed_count") == 0)
+            convertFromStringA( value.c_str(), pNotify->processed_count );
+        else if ( name.compare("cumulative_count") == 0)
+            convertFromStringA( value.c_str(), pNotify->cumulative_count );
+        else if ( name.compare("source_id") == 0)
+            convertFromStringA( value.c_str(), pNotify->source_id );
+        else if ( name.compare("error_code") == 0)
+            convertFromStringA( value.c_str(), pNotify->error_code );
+        else if ( name.compare("source_name") == 0)
+            pNotify->source_name = strdup(value.c_str());
+        else if ( name.compare("sync_type") == 0)
+            pNotify->sync_type = strdup(value.c_str());
+        else if ( name.compare("status") == 0)
+            pNotify->status = strdup(value.c_str());
+        else if ( name.compare("error_message") == 0)
+            pNotify->error_message = strdup(value.c_str());
+        else if ( name.compare("rho_callback") != 0)
+            break;
+
+        nLastPos = oTokenizer.getCurPos();
+    }
+
+    if ( nLastPos < (int)strlen(msg) )
+        pNotify->callback_params = strdup(msg+nLastPos);
+}
+
+unsigned long rho_syncclient_strarray_create()
+{
+    return (unsigned long)(new rho::Vector<rho::String>());
+}
+
+void rho_syncclient_strarray_add(unsigned long ar, const char* szStr)
+{
+    rho::Vector<rho::String>& arThis = *((rho::Vector<rho::String>*)ar);
+    arThis.addElement(szStr);
+}
+
+void rho_syncclient_strarray_delete(unsigned long ar)
+{
+    if (ar)
+        delete ((rho::Vector<rho::String>*)ar);
+}
+
+unsigned long rho_syncclient_strhasharray_create()
+{
+    return (unsigned long)(new VectorPtr<Hashtable<String, String>* >());
+}
+
+void rho_syncclient_strhasharray_add(unsigned long ar, unsigned long hash)
+{
+    VectorPtr<Hashtable<String, String>* >& arThis = *((VectorPtr<Hashtable<String, String>* >*)ar);
+    arThis.addElement( (Hashtable<String, String>*)hash );
+}
+
+void rho_syncclient_strhasharray_delete(unsigned long ar)
+{
+    if (ar)
+        delete ((VectorPtr<Hashtable<String, String>* >*)ar);
+}
+
+int rho_syncclient_strhasharray_size(unsigned long ar)
+{
+    VectorPtr<Hashtable<String, String>* >& arThis = *((VectorPtr<Hashtable<String, String>* >*)ar);
+    return arThis.size();
+}
+
+unsigned long rho_syncclient_strhasharray_get(unsigned long ar, int nIndex)
+{
+    VectorPtr<Hashtable<String, String>* >& arThis = *((VectorPtr<Hashtable<String, String>* >*)ar);
+    return (unsigned long) arThis.elementAt(nIndex);
+}
+
+unsigned long rho_syncclient_hash_create()
+{
+    return (unsigned long)(new rho::Hashtable<rho::String, rho::String>());
+}
+
+void rho_syncclient_hash_put(unsigned long hash, const char* szKey, const char* szValue)
+{
+    Hashtable<String, String>& hashThis = *((Hashtable<String, String>*)hash);
+    hashThis.put(szKey, szValue);
+}
+
+void rho_syncclient_hash_delete(unsigned long hash)
+{
+    if (hash)
+        delete ((rho::Hashtable<rho::String, rho::String>*)hash);
+}
+
+const char* rho_syncclient_hash_get(unsigned long hash, const char* szKey)
+{
+    Hashtable<String, String>& hashThis = *((Hashtable<String, String>*)hash);
+
+    if ( hashThis.containsKey(szKey) )
+        return hashThis[szKey].c_str();
+
+    return null;
+}
+
+int rho_syncclient_hash_equal(unsigned long hash1, unsigned long hash2)
+{
+    Hashtable<String, String>& hashThis1 = *((Hashtable<String, String>*)hash1);    
+    Hashtable<String, String>& hashThis2 = *((Hashtable<String, String>*)hash2);    
+
+    return hashThis1 == hashThis2 ? 1 : 0;
+}
+
+int rho_syncclient_hash_size(unsigned long hash)
+{
+    Hashtable<String, String>& hashThis = *((Hashtable<String, String>*)hash);
+	
+	return hashThis.size();
+}
+	
+void rho_syncclient_hash_enumerate(unsigned long hash, int (*enum_func)(const char* szKey, const char* szValue, void* pThis), void* pThis )
+{
+    Hashtable<String, String>& hashThis = *((Hashtable<String, String>*)hash);
+	
+	for ( Hashtable<String,String>::iterator it = hashThis.begin();  it != hashThis.end(); ++it )
+	{
+		if ( !(*enum_func)(it->first.c_str(), it->second.c_str(), pThis) )
+			return;
+	}		
+}
+	
+}
+
+String rhom_generate_id()
+{
+    static uint64 g_base_temp_id = 0;
+    if (  g_base_temp_id  == 0 )
+        g_base_temp_id = CLocalTime().toULong();
+
+    g_base_temp_id ++;
+    return convertToStringA(g_base_temp_id);
+}
+
+
+namespace rho {
+	const _CRhoAppAdapter& RhoAppAdapter = _CRhoAppAdapter();
+	
+	/*static*/ String _CRhoAppAdapter::getMessageText(const char* szName)
+	{
+		return String();
+	}
+	
+	/*static*/ String _CRhoAppAdapter::getErrorText(int nError)
+	{
+		return String();
+	}
+	
+	/*static*/ int  _CRhoAppAdapter::getErrorFromResponse(net::INetResponse& resp)
+	{
+		if ( !resp.isResponseRecieved())
+			return ERR_NETWORK;
+		
+		if ( resp.isUnathorized() )
+			return ERR_UNATHORIZED;
+		
+		if ( !resp.isOK() )
+			return ERR_REMOTESERVER;
+		
+		return ERR_NONE;
+	}
+	
+	/*static*/ void  _CRhoAppAdapter::loadServerSources(const String& strSources)
+	{
+		
+	}
+	
+    /*static*/ const char* _CRhoAppAdapter::getRhoDBVersion()
+	{
+		return "1.0";
+	}
+}
+
+extern "C" 
+{
+extern "C" void alert_show_popup(const char* message)
+{
+
+}
+
+const char* rho_ruby_getMessageText(const char* szName)
+{
+    return szName;
+}
+
+const char* rho_ruby_getErrorText(int nError)
+{
+    return "";
+}
+
+void rho_net_impl_network_indicator(int active)
+{
+//	[UIApplication sharedApplication].networkActivityIndicatorVisible = active ? YES : NO;
+}
+	
+}