rhoconnect-client 5.5.0

data/ext/rhoconnect-client/ext/shared/sync/SyncThread.h

@@ -0,0 +1,250 @@
+/*------------------------------------------------------------------------
+* (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
+*------------------------------------------------------------------------*/
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include "logging/RhoLog.h"
+#include "db/DBAdapter.h"
+#include "sync/SyncEngine.h"
+#include "common/ThreadQueue.h"
+#include "api_generator/MethodResult.h"
+
+namespace rho {
+namespace sync {
+
+class CSyncThread : public common::CThreadQueue
+{
+public:
+    enum ESyncCommands{ scNone = 0, scSyncAll, scSyncOne, scLogin, scSearchOne};
+
+private:
+
+    DEFINE_LOGCLASS;
+
+public:
+    static const unsigned int SYNC_WAIT_BEFOREKILL_SECONDS  = 3;
+
+    class CSyncCommand : public IQueueCommand
+    {
+    public:
+	    int m_nCmdCode;
+	    int m_nCmdParam;
+	    String m_strCmdParam, m_strQueryParams;
+   		boolean m_bShowStatus;
+		boolean m_bSyncOnlyChangedSources;
+
+	    CSyncCommand(int nCode, int nParam, boolean bShowStatus, const char * query_params, boolean bSyncOnlyChangedSources = false)
+	    {
+		    m_nCmdCode = nCode;
+		    m_nCmdParam = nParam;
+            m_bShowStatus = bShowStatus;
+            m_strQueryParams = query_params ? query_params : "";
+			m_bSyncOnlyChangedSources = bSyncOnlyChangedSources;
+	    }
+	    CSyncCommand(int nCode, String strParam, boolean bShowStatus, const char * query_params, boolean bSyncOnlyChangedSources = false )
+	    {
+		    m_nCmdCode = nCode;
+		    m_strCmdParam = strParam;
+            m_bShowStatus = bShowStatus;
+            m_strQueryParams = query_params ? query_params : "";
+			m_bSyncOnlyChangedSources = bSyncOnlyChangedSources;
+	    }
+	    CSyncCommand(int nCode, String strParam, int nCmdParam, boolean bShowStatus, const char * query_params, boolean bSyncOnlyChangedSources = false)
+	    {
+		    m_nCmdCode = nCode;
+		    m_strCmdParam = strParam;
+            m_nCmdParam = nCmdParam;
+            m_bShowStatus = bShowStatus;
+            m_strQueryParams = query_params ? query_params : "";
+			m_bSyncOnlyChangedSources = bSyncOnlyChangedSources;
+	    }
+
+	    CSyncCommand(int nCode, boolean bShowStatus, const char * query_params, boolean bSyncOnlyChangedSources = false)
+	    {
+		    m_nCmdCode = nCode;
+		    m_nCmdParam = 0;
+            m_bShowStatus = bShowStatus;
+            m_strQueryParams = query_params ? query_params : "";
+			m_bSyncOnlyChangedSources = bSyncOnlyChangedSources;
+	    }
+
+	    boolean equals(const IQueueCommand& cmd)
+	    {
+            const CSyncCommand& oSyncCmd = (const CSyncCommand&)cmd;
+		    return m_nCmdCode == oSyncCmd.m_nCmdCode && m_nCmdParam == oSyncCmd.m_nCmdParam &&
+			    m_strCmdParam == oSyncCmd.m_strCmdParam &&
+                m_strQueryParams == oSyncCmd.m_strQueryParams &&
+				m_bSyncOnlyChangedSources == oSyncCmd.m_bSyncOnlyChangedSources;
+	    }
+
+        virtual String toString();
+
+    };
+
+    class CSyncLoginCommand : public CSyncCommand
+    {
+    public:
+	    String m_strName, m_strPassword;
+        common::CAutoPtr<CSyncNotification> m_pNotify;
+        CSyncLoginCommand(String name, String password, CSyncNotification* pNotify) : 
+            CSyncCommand(CSyncThread::scLogin,"",false,"", false)
+	    {
+		    m_strName = name;
+		    m_strPassword = password;
+			m_pNotify = pNotify;
+	    }
+    };
+	
+    class CSyncSearchCommand : public CSyncCommand
+    {
+    public:
+	    String m_strFrom;
+        boolean m_bSyncChanges;
+        rho::Vector<rho::String> m_arSources;
+
+        CSyncSearchCommand(String from, String params, const rho::Vector<rho::String>& arSources, boolean sync_changes, int nProgressStep) : CSyncCommand(CSyncThread::scSearchOne,params,nProgressStep, false, "")
+	    {
+		    m_strFrom = from;
+            m_bSyncChanges = sync_changes;
+            m_arSources = arSources;
+	    }
+    };
+
+private:
+    static CSyncThread* m_pInstance;
+
+    CSyncEngine     m_oSyncEngine;
+public:
+    ~CSyncThread(void);
+
+    static CSyncThread* Create();
+    static void Destroy();
+    static CSyncThread* getInstance(){ return m_pInstance; }
+    static CSyncEngine& getSyncEngine(){ return m_pInstance->m_oSyncEngine; }
+
+	void setPollInterval(int nInterval);
+    
+    void stopAll();
+
+    unsigned long getRetValue();
+private:
+    CSyncThread();
+
+    virtual int getLastPollInterval();
+    virtual void processCommand(IQueueCommand* pCmd);
+    virtual boolean isSkipDuplicateCmd() { return true; }
+
+    virtual void onTimeout();
+
+    void checkShowStatus(CSyncCommand& oSyncCmd);
+};
+
+}
+}
+unsigned long rho_sync_doSearch(unsigned long ar_sources, const char *from, const char *params, bool sync_changes, int nProgressStep, const rho::apiGenerator::CMethodResult& oResult);
+unsigned long rho_sync_login(const char *login, const char *password, const rho::apiGenerator::CMethodResult& oResult);
+void rho_sync_set_notification(int source_id, const rho::apiGenerator::CMethodResult& oResult);
+#endif //__cplusplus
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+	
+unsigned long rho_sync_doSyncAllSources(int show_status_popup, const char * query_params, int sync_only_changed_sources);
+unsigned long rho_sync_doSyncSource(unsigned long nSrcID,int show_status_popup, const char * query_params);
+unsigned long rho_sync_doSyncSourceByID(int nSrcID);
+unsigned long rho_sync_doSyncSourceByName(const char* szSrcName);
+
+
+
+
+int rho_sync_logged_in();
+void rho_sync_logout();
+
+void rho_sync_clear_notification(int source_id);
+void rho_sync_set_source_property(int source_id, const char* propName, const char* propValue);
+int rho_sync_set_pollinterval(int nInterval);
+int rho_sync_get_pollinterval();
+void rho_sync_set_bulksyncstate(int new_state);
+bool rho_sync_has_bulksyncstate();
+int rho_sync_get_bulksyncstate();
+void rho_sync_set_syncserver(const char* syncserver);
+void rho_sync_setobjectnotify_url(const char* szUrl);
+void rho_sync_clear_object_notification();    
+void rho_sync_addobjectnotify(int nSrcID, const char* szObject);
+void rho_sync_cleanobjectnotify();
+int rho_sync_get_pagesize();
+void rho_sync_set_pagesize(int nPageSize);
+
+unsigned long rho_sync_get_attrs(const char* szPartition, int nSrcID);
+int rho_sync_get_lastsync_objectcount(int nSrcID);
+
+void rho_sync_set_threaded_mode(int b);
+char* rho_sync_create_string(const char* szStr);
+void rho_sync_free_string(char* szStr);
+
+unsigned long rho_sync_login_c(const char *name, const char *password, /*RHOC_CALLBACK*/void* callback, void* callback_data);
+unsigned long rho_sync_doSearchByNames(unsigned long ar_sources, const char *from, const char *params, bool sync_changes, int nProgressStep, /*RHOC_CALLBACK*/void* callback, void* callback_data);
+void rho_sync_set_notification_c(int source_id, /*RHOC_CALLBACK*/void* callback, void* callback_data);
+
+void rho_sync_setobjectnotify_url_c(/*RHOC_CALLBACK*/void* callback, void* callback_data);
+    
+void rho_sync_stop();
+void rho_sync_set_source_property(int nSrcID, const char* szPropName, const char* szPropValue);
+unsigned long rho_sync_get_source_property(int nSrcID, const char* szPropName);
+int  rho_sync_issyncing();
+
+void rho_sync_enable_status_popup(int b);
+void rho_sync_register_push();
+void rho_sync_set_ssl_verify_peer(int b);
+
+#ifdef __cplusplus
+};
+#endif //__cplusplus

data/ext/rhoconnect-client/ext.yml

@@ -0,0 +1,12 @@
+entry: Init_Rhoconnectclient_extension	
+javaentry: com.rhoconnect-client.Rhoconnect-client
+android_additional_sources_list: ext/platform/android/ext_java.files
+libraries: ["Rhoconnect-client"]
+
+project_paths:
+  wp8: ext/platform/wp8/Rhoconnect-client.vcxproj
+  wm: ext/platform/wm/Rhoconnect-client.vcproj
+
+xml_api_paths: ext/RhoConnectClient.xml
+android:
+  exttype: rakefile

data/lib/build/run_rhoconnect_spec.rb

@@ -0,0 +1,135 @@
+require 'fileutils'
+require File.join($rho_root,'lib','build','jake.rb')
+require File.join($rho_root,'lib','build','rhoconnect_helper.rb')
+
+def run_rhoconnect_spec(platform,appname,flags)
+	test_appname = "testapp"
+	puts "run_spec_app(#{platform},#{appname})"
+
+	rhobuildyml = File.join($rho_root,'rhobuild.yml')
+	$app_path = File.expand_path(File.join(File.dirname(__FILE__),'..','..','spec',appname))
+	puts "app path: #{$app_path}"
+
+	$app_config = Jake.config(File.open(File.join($app_path, "build.yml")))
+	config = Jake.config(File.open(rhobuildyml,'r'))
+
+	source_path = File.expand_path(File.join($app_path,'..','server'))
+	$tmp_path = File.join(File.dirname(__FILE__),'..','..','tmp')
+
+	cleanup_apps
+
+	FileUtils.mkdir_p File.expand_path($tmp_path)
+	server_path = File.expand_path(File.join($tmp_path,'testapp'))
+
+	$rhoconnect_bin = "#{$rhoconnect_root}/bin/rhoconnect"
+	puts "$rhoconnect_bin: #{$rhoconnect_bin}"
+
+	RhoconnectHelper.set_rhoconnect_bin $rhoconnect_root
+	puts "rhoconnect_bin: #{RhoconnectHelper.rhoconnect_bin}"
+
+	RhoconnectHelper.set_rc_out File.open( File.join($app_path, "rhoconnect.log" ), "w")
+	RhoconnectHelper.set_redis_out File.open( File.join($app_path, "redis.log" ), "w")
+	RhoconnectHelper.set_resque_out File.open( File.join($app_path, "resque.log" ), "w")
+	RhoconnectHelper.set_rc_push_out File.open( File.join($app_path, "rc_push.log" ), "w")
+	RhoconnectHelper.set_enable_push(false)
+	RhoconnectHelper.set_enable_rails(false)
+  pong = `redis-cli ping`
+	RhoconnectHelper.set_enable_redis(!(pong =~ /PONG/)) # Do not touch redis if it's running
+
+	RhoconnectHelper.stop_rhoconnect_stack
+
+  @mutex  = Mutex.new
+  # @signal = ConditionVariable.new
+  @server, @addr, @port = Jake.run_local_server(8081)
+	@server.mount_proc('/', nil) do |req, res|
+	  res.status = 200
+    @mutex.synchronize do
+      # puts " query_string: #{req.query_string}"
+      # puts " Body: #{req.body}"
+      @file_name =  req.query_string.split("=")[1]
+      xml_file = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', @file_name))
+      File.open(xml_file, "w") { |f| f << req.body }
+      puts "Test results are saved in #{@file_name}"
+      # @signal.signal
+    end
+	end
+	trap(:INT) { @server.shutdown }
+
+  puts "Generating app ..."
+  # Generate app, set rhoconnect gem path to its sources, but do not run bundler
+	res = RhoconnectHelper.generate_app($tmp_path, test_appname, false)
+
+  target_gemfile = File.join(server_path, 'Gemfile')
+	puts "Patching Gemfile with aws-s3 ..."
+	File.open(target_gemfile, 'a') {|f| f.puts "gem 'aws-s3', '>= 0.6.3'" }
+	puts "Patching Gemfile with sqlite3 ..."
+	File.open(target_gemfile, 'a') {|f| f.puts "gem 'sqlite3', '>= 1.3.3'" }
+	puts "Bundle install ..."
+	Kernel.system("bundle","install",:chdir => server_path)
+
+	puts "Adding source files ..."
+	FileUtils.cp_r ["#{source_path}/sources","#{source_path}/settings"], server_path
+
+	puts "Cleanup rhoconnect data ..."
+	FileUtils.rm_r(File.join(server_path,"data")) if File.directory?(File.join(server_path,"data"))
+
+	RhoconnectHelper.start_rhoconnect_stack(server_path,true)
+
+  generateRuby = flags && flags[:ruby]==true
+  generateJS = flags && flags[:js]==true
+
+  if generateRuby then
+    File.open(File.join($app_path, 'app', 'sync_server.rb'), 'w') do |f|
+  		f.puts "SYNC_SERVER_HOST = '#{RhoconnectHelper.host}'"
+   		f.puts "SYNC_SERVER_PORT = #{RhoconnectHelper.port}"
+    end
+    File.open(File.join($app_path, 'app', 'local_server.rb'), 'w') do |f|
+ 			f.puts "SPEC_LOCAL_SERVER_HOST = '#{@addr}'"
+ 			f.puts "SPEC_LOCAL_SERVER_PORT = #{@port}"
+    end
+  end
+
+  if generateJS then
+    File.open(File.join($app_path, 'public', 'app', 'sync_server.js'), 'w') do |f|
+      f.puts "var SYNC_SERVER_HOST = '#{RhoconnectHelper.host}';"
+      f.puts "var SYNC_SERVER_PORT = #{RhoconnectHelper.port};"
+    end
+    File.open(File.join($app_path, 'public', 'app', 'local_server.js'), 'w') do |f|
+			f.puts "var SPEC_LOCAL_SERVER_HOST = '#{@addr}';"
+ 			f.puts "var SPEC_LOCAL_SERVER_PORT = #{@port};"
+    end
+  end
+
+	puts "Running specs ..."
+	chdir $rho_root
+	Rake::Task.tasks.each { |t| t.reenable }
+	run_specs = $device && $device != "emulator" ? "run:#{platform}:#{$device}:spec" : "run:#{platform}:spec"
+
+  uninstall_app = false
+
+  	Rake::Task[run_specs].invoke(uninstall_app)
+
+
+rescue SystemExit => e
+  # FIXME: iphone rake task throws SystemExit exception. Swallow it!
+  # puts "Got exception: #{e}"
+rescue Exception => e
+  puts e.message
+  puts e.backtrace.join("\n")
+ensure
+  # @mutex.synchronize do
+  #   @signal.wait(@mutex, 30) # wait timeout
+  #   puts "Processed #{@file_name}"
+  # end
+	RhoconnectHelper.stop_rhoconnect_stack
+	cleanup_apps
+  Rake::Task["stop:#{platform}:#{$device}"].invoke
+  # TODO:
+  # `killall iphonesim_43 2> /dev/null` if platform == 'iphone'
+	puts "run_spec_app(#{platform},#{appname}) done"
+end
+
+def cleanup_apps
+	puts "cleanup"
+	FileUtils.rm_r File.expand_path($tmp_path) if File.directory?($tmp_path)
+end

data/lib/rhoconnect-client.rb

@@ -0,0 +1,3 @@
+$rhodes_extensions = []
+$rhodes_extensions << File.join(File.dirname(__FILE__),'..','ext')
+$rhodes_join_ext_name = true

data/platform/shared/RhoConnectClient/RhoConnectClient.cpp

@@ -0,0 +1,1673 @@
+/*------------------------------------------------------------------------
+* (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 "RhoConnectClient.h"
+
+//#include "stdafx.h"
+
+#include "common/RhodesAppBase.h"
+#include "sync/SyncThread.h"
+#include "sync/ClientRegister.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"
+#include "json/JSONIterator.h"
+
+using namespace rho;
+using namespace rho::common;
+using namespace rho::sync;
+using namespace rho::json;
+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_CONNECT_NOTIFY* pNotify);
+String rhom_generate_id();
+
+IDBResult rhom_executeSQL(const char* szSql, const char* szModel )
+{
+    Hashtable<String,db::CDBAdapter*>& mapDBPartitions = db::CDBAdapter::getDBPartitions();
+    IDBResult res = db::DBResultPtr(0);
+    for (Hashtable<String,db::CDBAdapter*>::iterator it = mapDBPartitions.begin();  it != mapDBPartitions.end(); ++it )
+    {
+        res = (it->second)->executeSQL(szSql, szModel );
+        if ( !res.isEnd() )
+            break;
+    }
+
+    return res;
+}
+
+extern "C" 
+{
+
+void rho_connectclient_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";
+    model->associations = rho_connectclient_hash_create();
+    model->blob_attribs = NULL;
+}
+
+void rho_connectclient_destroymodel(RHOM_MODEL* model)
+{
+    // foolproof, user may forget to do init
+    if (0 != model->associations) {
+        rho_connectclient_hash_delete(model->associations);
+    }
+    memset( model, 0, sizeof(RHOM_MODEL) );
+}
+
+static int get_start_id(const String& strPartition)
+{
+    db::CDBAdapter& dbPart = db::CDBAdapter::getDB(strPartition.c_str());
+    int nStartModelID = 1;
+    {
+        IDBResult  res = dbPart.executeSQL("SELECT MAX(source_id) AS maxid FROM sources");
+        if ( !res.isEnd() )
+            nStartModelID = res.getIntByIdx(0)+2;
+    }
+
+    if ( strPartition == "user" && nStartModelID < 1 )
+        nStartModelID = 1;
+    else if ( strPartition == "app" && nStartModelID < 20001 )
+        nStartModelID = 20001 + 2;
+    else if ( strPartition == "local" && nStartModelID < 40001 )
+        nStartModelID = 40001 + 2;
+
+    return nStartModelID;
+}
+
+static void rho_connectclient_processmodels( RHOM_MODEL* pModels, int nModels, const String& strPartition )
+{
+    int nStartModelID = get_start_id(strPartition);
+    db::CDBAdapter& dbPart = db::CDBAdapter::getDB(strPartition.c_str());
+
+    //create associations string
+    Hashtable<String, String> hashSrcAssoc;
+    for ( int i = 0; i < nModels; i++ )
+    { 
+        RHOM_MODEL& model = pModels[i];
+        if ( !model.associations || strPartition != model.partition )
+            continue;
+
+        Hashtable<String, String>& assocHash = *((Hashtable<String, String>*)model.associations);
+        for ( Hashtable<String,String>::iterator itAssoc = assocHash.begin();  itAssoc != assocHash.end(); ++itAssoc )
+        {
+            String strAssoc = hashSrcAssoc[itAssoc->second];
+            if (strAssoc.length() > 0 )
+                strAssoc += ",";
+
+            strAssoc += model.name;
+            strAssoc += "," + itAssoc->first;
+            hashSrcAssoc[itAssoc->second] = strAssoc;
+        }
+    }
+
+    for ( int i = 0; i < nModels; i++ )
+    { 
+        RHOM_MODEL& model = pModels[i];
+        if ( strPartition != model.partition )
+            continue;
+
+        IDBResult res = dbPart.executeSQL("SELECT sync_priority,source_id,partition, sync_type, schema_version, associations, blob_attribs FROM sources WHERE name=?",
+            model.name);
+
+        String strAssoc = hashSrcAssoc[model.name]; 
+
+        if ( !res.isEnd() )
+        {
+            dbPart.executeSQL("UPDATE sources SET sync_priority=?, sync_type=?, partition=?, schema=?, schema_version=?, associations=?, blob_attribs=? WHERE name=?",
+                model.sync_priority, getSyncTypeName(model.sync_type), model.partition, 
+                (model.type == RMT_PROPERTY_FIXEDSCHEMA ? "schema_model" : ""), "", strAssoc.c_str(), model.blob_attribs, model.name );
+            
+            model.source_id = res.getIntByIdx(1);
+            
+        }else //new model
+        {
+            dbPart.executeSQL("INSERT INTO sources (source_id,name,sync_priority, sync_type, partition, schema,schema_version, associations, blob_attribs) values (?,?,?,?,?,?,?,?,?) ",
+                nStartModelID, model.name, model.sync_priority, getSyncTypeName(model.sync_type), model.partition, 
+                (model.type == RMT_PROPERTY_FIXEDSCHEMA ? "schema_model" : ""), "", strAssoc.c_str(), model.blob_attribs );
+
+            model.source_id = nStartModelID;
+            nStartModelID++;
+        }
+    }
+}
+
+void rho_connectclient_init(RHOM_MODEL* pModels, int nModels)
+{
+    rho_logconf_Init(rho_native_rhopath(), rho_native_rhopath(), "");
+    CRhodesAppBase::Create( rho_native_rhopath(), rho_native_rhopath(), 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
+    Hashtable<String,db::CDBAdapter*>& mapDBPartitions = db::CDBAdapter::getDBPartitions();
+    for (Hashtable<String,db::CDBAdapter*>::iterator it = mapDBPartitions.begin();  it != mapDBPartitions.end(); ++it )
+    {
+        rho_connectclient_processmodels(pModels, nModels, it->first);
+    }
+
+    rho_db_init_attr_manager();
+
+    LOG(INFO) + "Starting sync engine...";
+    CSyncThread::Create();
+
+}
+
+void rho_connectclient_updatemodels(RHOM_MODEL* pModels, int nModels)
+{
+    for( int i = 0; i < nModels; i++ )
+    {
+        RHOM_MODEL& model = pModels[i];
+    
+        db::CDBAdapter& db = db::CDBAdapter::getDB( model.partition );
+        //, sync_type, sync_priority, associations, blob_attribs
+        IDBResult  res = db.executeSQL( "SELECT source_id from sources WHERE name=?", model.name );
+        if ( res.isEnd() )
+            continue;
+
+        model.source_id = res.getIntByIdx(0);
+        //model.sync_type = (RHOM_SYNC_TYPE)res.getIntByIdx(1);
+    }
+}
+
+void rho_connectclient_database_client_reset()
+{
+    int pollInterval = rho_sync_set_pollinterval(0);
+    rho_sync_stop();
+    
+    db::CDBAdapter& oUserDB = db::CDBAdapter::getUserDB();
+    oUserDB.executeSQL("UPDATE client_info SET client_id=?, token=?, token_sent=?", "", "", 0);
+    
+    if ( rho_conf_is_property_exists("bulksync_state") )
+        rho_conf_setInt("bulksync_state", 0 );
+    
+    Vector<String> arExclude;
+    arExclude.addElement("sources");
+    arExclude.addElement("client_info");
+    
+    Vector<String> arPartNames = db::CDBAdapter::getDBAllPartitionNames();
+    for( int i = 0; i < (int)arPartNames.size(); i++ )
+    {
+        db::CDBAdapter& dbPart = db::CDBAdapter::getDB(arPartNames.elementAt(i).c_str());
+        
+        dbPart.executeSQL("UPDATE sources SET token=0");
+        dbPart.destroy_tables(Vector<String>(), arExclude);
+        //db::CDBAdapter::destroy_tables_allpartitions(Vector<String>(), arExclude);
+    }
+    
+    rho_db_init_attr_manager();
+
+    //hash_migrate = {}
+    //::Rho::RHO.init_schema_sources(hash_migrate)
+    
+    rho_sync_set_pollinterval(pollInterval);
+}
+
+void rho_connectclient_database_full_reset_and_logout()
+{
+    rho_sync_logout();
+	rho_connectclient_database_full_reset(false);
+}
+
+void rho_connectclient_database_fullclient_reset_and_logout()
+{
+	rho_sync_logout();
+	rho_connectclient_database_full_reset(true);
+}
+	
+void rho_connectclient_database_full_reset(bool bClientReset)
+{
+    int pollInterval = rho_sync_set_pollinterval(0);
+    rho_sync_stop();
+    
+    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");
+	if (!bClientReset)
+		arExclude.addElement("client_info");
+
+    Vector<String> arPartNames = db::CDBAdapter::getDBAllPartitionNames();
+    for( int i = 0; i < (int)arPartNames.size(); i++ )
+    {
+        db::CDBAdapter& dbPart = db::CDBAdapter::getDB(arPartNames.elementAt(i).c_str());
+
+        dbPart.executeSQL("UPDATE sources SET token=0");
+        dbPart.destroy_tables(Vector<String>(), arExclude);
+        //db::CDBAdapter::destroy_tables_allpartitions(Vector<String>(), arExclude);
+    }
+
+	if (!bClientReset)
+        rho_conf_setString("push_pin", "");
+    
+    rho_db_init_attr_manager();
+    //hash_migrate = {}
+    //::Rho::RHO.init_schema_sources(hash_migrate)
+    
+    rho_sync_set_pollinterval(pollInterval);
+}
+	
+char* rho_connectclient_database_export(const char* partition)
+{
+	db::CDBAdapter& db = db::CDBAdapter::getDB(partition);	
+	return strdup(db.exportDatabase().c_str());
+}
+
+int rho_connectclient_database_import(const char* partition, const char* zipName)
+{
+	db::CDBAdapter& db = db::CDBAdapter::getDB(partition);
+	return db.importDatabase(zipName) ? 1 : 0;
+}
+
+void rho_connectclient_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(IDBResult& res1, int nSrcID, bool isSchemaSrc)
+{
+    unsigned long item = 0;
+    if ( res1.isEnd() )
+        return item;
+
+    item = rho_connectclient_hash_create();
+    rho_connectclient_hash_put(item, "source_id", convertToStringA(nSrcID).c_str() );
+
+    if (!isSchemaSrc)
+    {
+        for ( ; !res1.isEnd(); res1.next() )
+        {
+            if ( !res1.isNullByIdx(1) )
+                rho_connectclient_hash_put(item, res1.getStringByIdx(0).c_str(), res1.getStringByIdx(1).c_str() );
+        }
+    }else
+    {
+        for (int i = 0; i < res1.getColCount(); i++ )
+        {
+            if ( !res1.isNullByIdx(i))
+                rho_connectclient_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=?";
+        IDBResult res1 = db.executeSQL(sql.c_str(), szObject, nSrcID);
+        item = rhom_make_object(res1, nSrcID, isSchemaSrc);
+        if (item)
+            rho_connectclient_hash_put(item, "object", szObject.c_str() );
+    }else
+    {
+        String sql = "SELECT * FROM " + src_name + " WHERE object=? LIMIT 1 OFFSET 0";
+        IDBResult res1 = db.executeSQL(sql.c_str(), szObject);
+        item = rhom_make_object(res1, nSrcID, isSchemaSrc);
+    }
+
+    return item;
+}
+
+unsigned long rho_connectclient_find(const char* szModel,const char* szObject )
+{
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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, szModel, nSrcID, szObject, isSchemaSrc);
+}
+
+unsigned long rhom_find(const char* szModel, unsigned long hash, int nCount )
+{
+    String src_name = szModel;
+
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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);
+			}
+		}
+    }
+
+    IDBResult  res1 = db.executeSQLEx(sql.c_str(), arValues );
+
+    if ( nCount == 1 )
+    {
+        return rhom_load_item_by_object(db, src_name, nSrcID, res1.getStringByIdx(0), isSchemaSrc);
+    }
+
+    unsigned long items = rho_connectclient_strhasharray_create();
+    for ( ; !res1.isEnd(); res1.next() )
+    {
+        rho_connectclient_strhasharray_add(items, 
+            rhom_load_item_by_object(db, src_name, nSrcID, res1.getStringByIdx(0), isSchemaSrc) );
+    }
+
+    return items;
+}
+
+unsigned long rho_connectclient_find_all(const char* szModel, unsigned long hash )
+{
+    return rhom_find( szModel, hash, -1 );
+}
+
+unsigned long rho_connectclient_find_first(const char* szModel, unsigned long hash )
+{
+    return rhom_find( szModel, hash, 1 );
+}
+
+unsigned long rho_connectclient_findbysql(const char* szModel, const char* szSql, unsigned long arParams )
+{
+    String src_name = szModel;
+
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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;
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    unsigned long items = rho_connectclient_strhasharray_create();
+
+    IDBResult res1 = !arParams ? db.executeSQL(szSql) : db.executeSQLEx( szSql, *((Vector<String>*) arParams) );
+    if ( res1.isEnd() )
+        return items;
+
+    for ( ; !res1.isEnd(); res1.next() )
+    {
+        unsigned long item = rho_connectclient_hash_create();
+
+        for (int i = 0; i < res1.getColCount(); i++ )
+        {
+            if ( !res1.isNullByIdx(i))
+                rho_connectclient_hash_put(item, res1.getColName(i).c_str(), res1.getStringByIdx(i).c_str() );
+        }
+
+        rho_connectclient_strhasharray_add(items, item ); 
+    }
+
+    return items;
+
+}
+
+void rho_connectclient_start_bulkupdate(const char* szModel)
+{
+    String src_name = szModel;
+
+    IDBResult  res = rhom_executeSQL("SELECT partition from sources WHERE name=?", szModel);
+    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_connectclient_stop_bulkupdate(const char* szModel)
+{
+    String src_name = szModel;
+    IDBResult  res = rhom_executeSQL("SELECT partition from sources WHERE name=?", szModel);
+    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_connectclient_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";
+
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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 )
+    {
+        IDBResult attrsList = db.executeSQL( ("SELECT * FROM " + tableName + " WHERE object=?").c_str(), obj);
+        if ( !attrsList.isEnd() )
+            item = rhom_make_object(attrsList,nSrcID,isSchemaSrc);
+    }else
+    {
+        IDBResult 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 )
+    {
+        IDBResult 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_connectclient_hash_delete(item);
+        }
+    }
+
+    db.endTransaction();
+}
+
+void rho_connectclient_on_sync_create_error(const char* szModel, RHO_CONNECT_NOTIFY* pNotify, const char* szAction )
+{
+    unsigned long hash_create_errors = pNotify->create_errors_messages;
+    if (!hash_create_errors)
+        return;
+
+    String src_name = szModel;
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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();
+
+    Hashtable<String, String>& hashCreateErrors = *((Hashtable<String, String>*)hash_create_errors);
+
+    for ( Hashtable<String,String>::iterator it = hashCreateErrors.begin();  it != hashCreateErrors.end(); ++it )
+    {
+        String obj = it->first;
+        if ( strcmp(szAction, "recreate") == 0 )
+        {
+            IDBResult deletes = db.executeSQL( "SELECT object FROM changed_values WHERE update_type=? and object=? and source_id=?", "delete", obj, nSrcID );
+            if (deletes.isEnd()) 
+            {
+                db.executeSQL( "DELETE FROM changed_values WHERE object=? and source_id=?", obj, nSrcID );
+                Hashtable<String,String> fields;
+                fields.put("update_type", "create");
+                fields.put("attrib", "object");
+                fields.put("source_id", convertToStringA(nSrcID));
+                fields.put("object", obj);
+                db_insert_into_table(db, "changed_values", fields);
+                continue;
+            }
+        }
+
+        db.executeSQL( "DELETE FROM changed_values WHERE object=? and source_id=?", obj, nSrcID );
+        if ( isSchemaSrc )
+            db.executeSQL( (String("DELETE FROM ") + tableName + " WHERE object=?").c_str(), obj );
+        else
+            db.executeSQL( (String("DELETE FROM ") + tableName + " WHERE object=? and source_id=?").c_str(), obj, nSrcID );
+    }
+
+    db.endTransaction();
+}
+
+void rho_connectclient_push_changes(const char* szModel )
+{
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return;
+    }
+
+    int nSrcID = res.getIntByIdx(0);
+    String db_partition = res.getStringByIdx(1);
+    bool isSyncSrc = res.getStringByIdx(3).compare("none") != 0;
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    if (!isSyncSrc)
+        return;
+
+    Hashtable<String,String> fields;
+    fields.put("update_type", "push_changes");
+    fields.put("source_id", convertToStringA(nSrcID));
+    db_insert_into_table(db, "changed_values", fields);
+}
+
+void _insert_or_update_attr(db::CDBAdapter& db, bool isSchemaSrc, const String& tableName, int nSrcID, const String& obj, const String& attrib, const String& new_val)
+{
+    if ( isSchemaSrc )
+    {
+        IDBResult result = db.executeSQL( ("SELECT * FROM " + tableName + " WHERE object=?").c_str(), obj);
+        if ( !result.isEnd() )
+            db.executeSQL( (String("UPDATE ") + tableName + " SET " + attrib + "=? WHERE object=?").c_str(), new_val, obj );
+        else
+        {
+            Hashtable<String,String> fields;
+            fields.put("object", obj);
+            fields.put("attrib", new_val);
+            db_insert_into_table(db, tableName, fields);
+        }
+    } 
+    else  
+    {
+        IDBResult result = db.executeSQL( ("SELECT attrib, value FROM " + tableName + " WHERE object=? and source_id=?").c_str(), obj, nSrcID);
+        if ( !result.isEnd() )
+            db.executeSQL( "UPDATE object_values SET value=? WHERE object=? and attrib=? and source_id=?", new_val, obj, attrib, nSrcID );
+        else
+        {
+            Hashtable<String,String> fields;
+            fields.put("source_id", convertToStringA(nSrcID));
+            fields.put("object", obj);
+            fields.put("attrib", attrib);
+            fields.put("value", new_val);
+            db_insert_into_table(db, tableName, fields);
+        }
+    }
+}
+
+void rho_connectclient_on_sync_update_error(const char* szModel, RHO_CONNECT_NOTIFY* pNotify, const char* szAction )
+{
+    String src_name = szModel;
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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();
+
+    if ( strcmp(szAction, "rollback") == 0 )
+    {
+        rho::Vector<rho::String>& arObjs = *((rho::Vector<rho::String>*)pNotify->update_rollback_obj);
+        for (int i = 0; i < (int)arObjs.size(); i++)
+        {
+            String obj = arObjs[i];
+
+            Hashtable<String, String>& hashUpdateAttrs = *((Hashtable<String, String>*)rho_connectclient_strhasharray_get(pNotify->update_rollback_attrs,i));
+            for ( Hashtable<String,String>::iterator it = hashUpdateAttrs.begin();  it != hashUpdateAttrs.end(); ++it )
+            {
+                String attrib = it->first;
+                String value = it->second;
+
+                _insert_or_update_attr(db, isSchemaSrc, tableName, nSrcID, obj, attrib, value);
+            }
+        }
+    }else
+    {
+        rho::Vector<rho::String>& arObjs = *((rho::Vector<rho::String>*)pNotify->update_errors_obj);
+        for (int i = 0; i < (int)arObjs.size(); i++)
+        {
+            String obj = arObjs[i];
+
+            Hashtable<String, String>& hashUpdateAttrs = *((Hashtable<String, String>*)rho_connectclient_strhasharray_get(pNotify->update_errors_attrs,i));
+            for ( Hashtable<String,String>::iterator it = hashUpdateAttrs.begin();  it != hashUpdateAttrs.end(); ++it )
+            {
+                String attrib = it->first;
+                String value = it->second;
+
+                IDBResult resUpdateType = db.executeSQL( "SELECT update_type FROM changed_values WHERE object=? and source_id=? and attrib=? and sent=?", obj, nSrcID, attrib, 0 );
+                if (resUpdateType.isEnd())
+                {
+                    String attrib_type = db::CDBAdapter::getDB(db_partition.c_str()).getAttrMgr().isBlobAttr(nSrcID, attrib.c_str()) ? "blob.file" : "";
+                    Hashtable<String,String> fields;
+                    fields.put("update_type", "update");
+                    fields.put("attrib", attrib);
+                    fields.put("attrib_type", attrib_type);
+                    fields.put("source_id", convertToStringA(nSrcID));
+                    fields.put("object", obj);
+                    fields.put("value", value);
+                    db_insert_into_table(db, "changed_values", fields);
+                }
+            }
+        }
+    }
+
+    db.endTransaction();
+}
+
+void rho_connectclient_on_sync_delete_error(const char* szModel, RHO_CONNECT_NOTIFY* pNotify, const char* szAction )
+{
+    String src_name = szModel;
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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();
+
+    rho::Vector<rho::String>& arObjs = *((rho::Vector<rho::String>*)pNotify->delete_errors_obj);
+    for (int i = 0; i < (int)arObjs.size(); i++)
+    {
+        String obj = arObjs[i];
+
+        Hashtable<String, String>& hashDeleteAttrs = *((Hashtable<String, String>*)rho_connectclient_strhasharray_get(pNotify->delete_errors_attrs,i));
+        for ( Hashtable<String,String>::iterator it = hashDeleteAttrs.begin();  it != hashDeleteAttrs.end(); ++it )
+        {
+            String attrib = it->first;
+            String value = it->second;
+
+            IDBResult resUpdateType = db.executeSQL( "SELECT update_type FROM changed_values WHERE object=? and source_id=? and attrib=? and sent=?", obj, nSrcID, attrib, 0 );
+            if (resUpdateType.isEnd())
+            {
+                String attrib_type = db::CDBAdapter::getDB(db_partition.c_str()).getAttrMgr().isBlobAttr(nSrcID, attrib.c_str()) ? "blob.file" : "";
+                Hashtable<String,String> fields;
+                fields.put("update_type", "delete");
+                fields.put("attrib", attrib);
+                fields.put("attrib_type", attrib_type);
+                fields.put("source_id", convertToStringA(nSrcID));
+                fields.put("object", obj);
+                fields.put("value", value);
+                db_insert_into_table(db, "changed_values", fields);
+            }
+        }
+    }
+
+    db.endTransaction();
+}
+
+void rho_connectclient_save( const char* szModel, unsigned long hash )
+{
+    Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
+    String src_name = szModel;
+
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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.Lock();
+
+    String sql;
+    Vector<String> arValues;
+    bool is_new_item = false;
+
+    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));
+    }
+    IDBResult res1 = db.executeSQLEx(sql.c_str(), arValues );
+    if (res1.isEnd())
+    {
+        rho_connectclient_create_object(szModel, hash);
+        is_new_item = true;
+    }
+
+    db.Unlock();
+
+    if ( is_new_item )
+        return;
+
+    db.startTransaction();
+    String update_type = "update";
+    bool ignore_changed_values = true;
+    if (isSyncSrc)
+    {
+        IDBResult 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";
+
+        ignore_changed_values = update_type=="create";
+    }
+
+    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 (!ignore_changed_values)
+                {
+                    IDBResult 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 (!ignore_changed_values )
+                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_connectclient_create_object(const char* szModel, unsigned long hash)
+{
+    Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
+    String src_name = szModel;
+
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", szModel);
+    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 ( isSyncSrc )
+    {
+        Hashtable<String,String> fields;
+        fields.put("source_id", convertToStringA(nSrcID));
+        fields.put("object", obj);
+        fields.put("attrib", "object");
+        fields.put("update_type", "create");
+
+        db_insert_into_table(db, "changed_values", fields ); 
+    }
+
+    if ( isSchemaSrc )
+        db_insert_into_table(db, tableName, hashObject, "source_id");
+    else                    
+    {
+        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;
+
+            Hashtable<String,String> fields;
+            fields.put("source_id", convertToStringA(nSrcID));
+            fields.put("object", obj);
+            fields.put("attrib", key);
+            fields.put("value", val);
+
+            db_insert_into_table(db, tableName, fields);
+        }
+    }
+                        
+    db.endTransaction();
+}
+
+int rho_connectclient_is_changed(const char* szModel)
+{
+    String src_name = szModel;
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition from sources WHERE name=?", szModel);
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return 0;
+    }
+
+    int nSrcID = res.getIntByIdx(0);
+    String db_partition = res.getStringByIdx(1);
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    IDBResult resChanged = db.executeSQL("SELECT object FROM changed_values WHERE source_id=? LIMIT 1 OFFSET 0", nSrcID);
+
+    return resChanged.isEnd() ? 0 : 1;
+}
+
+void rho_connectclient_set_synctype(const char* szModel, RHOM_SYNC_TYPE sync_type)
+{
+    IDBResult  res = rhom_executeSQL("SELECT source_id, partition from sources WHERE name=?", szModel);
+    if ( res.isEnd())
+    {
+        //TODO: report error - unknown source
+        return;
+    }
+
+    int nSrcID = res.getIntByIdx(0);
+    String db_partition = res.getStringByIdx(1);
+    db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
+
+    db.executeSQL("UPDATE sources SET sync_type=? WHERE name=?", getSyncTypeName(sync_type), szModel );
+}
+
+void parseServerErrors( CJSONEntry oEntry, unsigned long& errors_obj, unsigned long& errors_attrs )
+{
+    if (!errors_obj)
+        errors_obj = rho_connectclient_strarray_create();
+
+    CJSONStructIterator oIter(oEntry);
+    for( ; !oIter.isEnd(); oIter.next() )
+    {
+        CJSONEntry oObjEntry = oIter.getCurValue();
+
+        String strObject = oIter.getCurKey();
+        int nObj = rho_connectclient_strarray_find(errors_obj, strObject.c_str() ); 
+        if ( nObj < 0 )
+            nObj = rho_connectclient_strarray_add(errors_obj, strObject.c_str() );
+
+        if (oObjEntry.hasName("attributes"))
+        {
+            CJSONEntry oAttrEntry = oObjEntry.getEntry("attributes");
+            CJSONStructIterator oAttrIter(oAttrEntry);
+            for( ; !oAttrIter.isEnd(); oAttrIter.next() )
+            {
+                String strAttr = oAttrIter.getCurKey();
+                if (!errors_attrs)
+                    errors_attrs = rho_connectclient_strhasharray_create();
+
+                VectorPtr<Hashtable<String, String>* >& arAttrs = *((VectorPtr<Hashtable<String, String>* >*)errors_attrs);
+                if ( nObj < (int)arAttrs.size() )
+                    arAttrs[nObj]->put(strAttr, oAttrIter.getCurString());
+                else
+                {
+                    unsigned long hashAttrs = rho_connectclient_hash_create();
+                    rho_connectclient_hash_put(hashAttrs, strAttr.c_str(), oAttrIter.getCurString().c_str());
+                    arAttrs.addElement( (Hashtable<String, String>*)hashAttrs );
+                }
+            }
+        }
+    }
+}
+    
+void parseServerErrorMessage( CJSONEntry oEntry, unsigned long& errors_obj )
+{
+    if (!errors_obj)
+        errors_obj = rho_connectclient_hash_create();
+
+    CJSONStructIterator oIter(oEntry);
+    for( ; !oIter.isEnd(); oIter.next() )
+    {
+        CJSONEntry oObjEntry = oIter.getCurValue();
+
+        if (oObjEntry.hasName("message"))
+        {
+            CJSONEntry oMsgEntry = oObjEntry.getEntry("message");
+            rho_connectclient_hash_put(errors_obj, oIter.getCurKey().c_str(), oMsgEntry.getString());
+        }
+    }
+    
+}
+
+
+void rho_connectclient_parsenotify(const char* msg, RHO_CONNECT_NOTIFY* pNotify)
+{
+    // for the case it has been called in single-threaded mode,
+    // so notification message may be NULL
+    if (NULL == msg)
+        return;
+
+    CJSONEntry oMsg(msg);
+    if ( oMsg.hasName("total_count") )
+        convertFromStringA( oMsg.getString("total_count"), pNotify->total_count );
+    if ( oMsg.hasName("processed_count"))
+        convertFromStringA( oMsg.getString("processed_count"), pNotify->processed_count );
+    if ( oMsg.hasName("cumulative_count"))
+        convertFromStringA( oMsg.getString("cumulative_count"), pNotify->cumulative_count );
+    if ( oMsg.hasName("source_id"))
+        convertFromStringA( oMsg.getString("source_id"), pNotify->source_id );
+    if ( oMsg.hasName("error_code") )
+        convertFromStringA( oMsg.getString("error_code"), pNotify->error_code );
+    if ( oMsg.hasName("source_name") )
+        pNotify->source_name = strdup(oMsg.getString("source_name"));
+    if ( oMsg.hasName("sync_type") )
+        pNotify->sync_type = strdup(oMsg.getString("sync_type"));
+    if ( oMsg.hasName("bulk_status") )
+        pNotify->bulk_status = strdup(oMsg.getString("bulk_status"));
+    if ( oMsg.hasName("partition") )
+        pNotify->partition = strdup(oMsg.getString("partition"));
+    if ( oMsg.hasName("status") )
+        pNotify->status = strdup(oMsg.getString("status"));
+    if ( oMsg.hasName("error_message") )
+        pNotify->error_message = strdup(oMsg.getString("error_message"));
+
+    if ( oMsg.hasName("server_errors") )
+    {
+        CJSONEntry oSrvErrors = oMsg.getEntry("server_errors");
+        if ( oSrvErrors.hasName("create-error") )
+            parseServerErrorMessage(oSrvErrors.getEntry("create-error"), pNotify->create_errors_messages);
+        if ( oSrvErrors.hasName("update-error") )
+        {
+            parseServerErrors( oSrvErrors.getEntry("update-error"), pNotify->update_errors_obj, pNotify->update_errors_attrs );
+            parseServerErrorMessage(oSrvErrors.getEntry("update-error"), pNotify->update_errors_messages);
+        }
+        if ( oSrvErrors.hasName("update-rollback") )
+        {
+            parseServerErrors( oSrvErrors.getEntry("update-rollback"), pNotify->update_rollback_obj, pNotify->update_rollback_attrs );
+        }
+        if ( oSrvErrors.hasName("delete-error") )
+        {
+            parseServerErrors( oSrvErrors.getEntry("delete-error"), pNotify->delete_errors_obj, pNotify->delete_errors_attrs );
+            parseServerErrorMessage(oSrvErrors.getEntry("delete-error"), pNotify->delete_errors_messages);
+        }
+    }
+}
+
+void rho_connectclient_free_syncnotify(RHO_CONNECT_NOTIFY* pNotify)
+{
+    if (!pNotify)
+        return;
+    
+    if ( pNotify->source_name != null )
+        free(pNotify->source_name);
+    
+    if ( pNotify->sync_type != null )
+        free(pNotify->sync_type);
+
+    if ( pNotify->bulk_status != null )
+        free(pNotify->bulk_status);
+
+    if ( pNotify->partition != null )
+        free(pNotify->partition);
+
+    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);
+
+    if ( pNotify->create_errors_messages != null )
+        rho_connectclient_hash_delete(pNotify->create_errors_messages);
+
+    if ( pNotify->update_errors_obj != null )
+        rho_connectclient_strarray_delete(pNotify->update_errors_obj);
+
+    if ( pNotify->update_errors_attrs != null )
+        rho_connectclient_strhasharray_delete(pNotify->update_errors_attrs);
+    
+    if ( pNotify->update_errors_messages != null )
+        rho_connectclient_hash_delete(pNotify->update_errors_messages);
+
+    if ( pNotify->update_rollback_obj != null )
+        rho_connectclient_strarray_delete(pNotify->update_rollback_obj);
+
+    if ( pNotify->update_rollback_attrs != null )
+        rho_connectclient_strhasharray_delete(pNotify->update_rollback_attrs);
+
+    if ( pNotify->delete_errors_obj != null )
+        rho_connectclient_strarray_delete(pNotify->delete_errors_obj);
+
+    if ( pNotify->delete_errors_attrs != null )
+        rho_connectclient_strhasharray_delete(pNotify->delete_errors_attrs);
+    
+    if ( pNotify->delete_errors_messages != null )
+        rho_connectclient_hash_delete(pNotify->delete_errors_messages);
+
+    memset( pNotify, 0, sizeof(RHO_CONNECT_NOTIFY) );
+}
+    
+void rho_connectclient_parse_objectnotify(const char* msg, RHO_CONNECT_OBJECT_NOTIFY* pNotify)
+{
+    //TODO: parse json and make tests
+/*    {
+        CTokenizer oTokenizer( msg, "&" );
+        while (oTokenizer.hasMoreTokens()) 
+        {
+            String tok = oTokenizer.nextToken();
+            if (tok.length() == 0)
+                continue;
+        
+            CTokenizer oValueTok( tok, "=" );
+            String name = net::URI::urlDecode(oValueTok.nextToken());
+        
+            if ( String_startsWith(name, "deleted[][object]"))
+                pNotify->deleted_count++;
+            else if ( String_startsWith(name, "updated[][object]")) 
+                pNotify->updated_count++;
+            else  if ( String_startsWith(name, "created[][object]")) 
+                pNotify->created_count++; 
+        }
+    }
+    
+    if ( pNotify->deleted_count > 0 )
+    {
+        pNotify->deleted_source_ids = new int[pNotify->deleted_count];
+        pNotify->deleted_objects = new char*[pNotify->deleted_count];
+    }
+    
+    if ( pNotify->updated_count > 0 )
+    {
+        pNotify->updated_source_ids = new int[pNotify->updated_count];
+        pNotify->updated_objects = new char*[pNotify->updated_count];
+    }
+
+    if ( pNotify->created_count > 0 )
+    {
+        pNotify->created_source_ids = new int[pNotify->created_count];
+        pNotify->created_objects = new char*[pNotify->created_count];
+    }
+
+    {
+        CTokenizer oTokenizer( msg, "&" );
+        int nDeleted = 0, nUpdated = 0, nCreated = 0;
+        while (oTokenizer.hasMoreTokens()) 
+        {
+            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 ( String_startsWith(name, "deleted[][object]"))
+            {
+                pNotify->deleted_objects[nDeleted] = strdup(value.c_str());
+                nDeleted++;
+            }else if (String_startsWith(name, "deleted[][source_id]"))
+                convertFromStringA( value.c_str(), pNotify->deleted_source_ids[nDeleted] );
+            else if ( String_startsWith(name, "updated[][object]")) 
+            {
+                pNotify->updated_objects[nUpdated] = strdup(value.c_str());
+                nUpdated++;
+            }else if (String_startsWith(name, "updated[][source_id]"))
+                convertFromStringA( value.c_str(), pNotify->updated_source_ids[nUpdated] );
+            else  if ( String_startsWith(name, "created[][object]")) 
+            {
+                pNotify->created_objects[nCreated] = strdup(value.c_str());
+                nCreated++;
+            }else if (String_startsWith(name, "created[][source_id]"))
+                convertFromStringA( value.c_str(), pNotify->created_source_ids[nCreated] );
+        }
+    }*/
+}
+    
+void rho_connectclient_free_sync_objectnotify(RHO_CONNECT_OBJECT_NOTIFY* pNotify)
+{
+    if (!pNotify)
+        return;
+    
+    if ( pNotify->deleted_source_ids != null )
+        free(pNotify->deleted_source_ids);
+
+    if ( pNotify->updated_source_ids != null )
+        free(pNotify->updated_source_ids);
+
+    if ( pNotify->created_source_ids != null )
+        free(pNotify->created_source_ids);
+    
+    if ( pNotify->deleted_objects != null )
+    {
+        for(int i = 0; i < pNotify->deleted_count; i++)
+            free(pNotify->deleted_objects[i]);
+        
+        free(pNotify->deleted_objects);
+    }
+
+    if ( pNotify->updated_objects != null )
+    {
+        for(int i = 0; i < pNotify->updated_count; i++)
+            free(pNotify->updated_objects[i]);
+        
+        free(pNotify->updated_objects);
+    }
+
+    if ( pNotify->created_objects != null )
+    {
+        for(int i = 0; i < pNotify->created_count; i++)
+            free(pNotify->created_objects[i]);
+        
+        free(pNotify->created_objects);
+    }
+    
+    memset( pNotify, 0, sizeof(RHO_CONNECT_OBJECT_NOTIFY) );        
+}
+
+unsigned long rho_connectclient_strarray_create()
+{
+    return (unsigned long)(new rho::Vector<rho::String>());
+}
+
+int rho_connectclient_strarray_add(unsigned long ar, const char* szStr)
+{
+    rho::Vector<rho::String>& arThis = *((rho::Vector<rho::String>*)ar);
+    arThis.addElement(szStr);
+
+    return arThis.size()-1;
+}
+
+void rho_connectclient_strarray_delete(unsigned long ar)
+{
+    if (ar)
+        delete ((rho::Vector<rho::String>*)ar);
+}
+
+int rho_connectclient_strarray_find(unsigned long ar, const char* szStr)
+{
+    rho::Vector<rho::String>& arThis = *((rho::Vector<rho::String>*)ar);
+    for (int i = 0; i < (int)arThis.size(); i++)
+    {
+        if (arThis[i].compare(szStr) == 0)
+            return i;
+    }
+
+    return -1;
+}
+
+unsigned long rho_connectclient_strhasharray_create()
+{
+    return (unsigned long)(new VectorPtr<Hashtable<String, String>* >());
+}
+
+void rho_connectclient_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_connectclient_strhasharray_delete(unsigned long ar)
+{
+    if (ar)
+        delete ((VectorPtr<Hashtable<String, String>* >*)ar);
+}
+
+int rho_connectclient_strhasharray_size(unsigned long ar)
+{
+    VectorPtr<Hashtable<String, String>* >& arThis = *((VectorPtr<Hashtable<String, String>* >*)ar);
+    return arThis.size();
+}
+
+unsigned long rho_connectclient_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_connectclient_hash_create()
+{
+    return (unsigned long)(new rho::Hashtable<rho::String, rho::String>());
+}
+
+void rho_connectclient_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_connectclient_hash_delete(unsigned long hash)
+{
+    if (hash)
+        delete ((rho::Hashtable<rho::String, rho::String>*)hash);
+}
+
+const char* rho_connectclient_hash_get(unsigned long hash, const char* szKey)
+{
+    if (!hash)
+        return null;
+
+    Hashtable<String, String>& hashThis = *((Hashtable<String, String>*)hash);
+
+    if ( hashThis.containsKey(szKey) )
+        return hashThis[szKey].c_str();
+
+    return null;
+}
+
+int rho_connectclient_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_connectclient_hash_size(unsigned long hash)
+{
+    Hashtable<String, String>& hashThis = *((Hashtable<String, String>*)hash);
+	
+	return hashThis.size();
+}
+	
+void rho_connectclient_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(); //TODO?
+	}
+	
+	/*static*/ int  _CRhoAppAdapter::getErrorFromResponse(NetResponse& 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*/ void  _CRhoAppAdapter::loadAllSyncSources()
+	{
+		
+	}
+	
+    /*static*/ const char* _CRhoAppAdapter::getRhoDBVersion()
+	{
+		return "1.0";
+	}
+	
+	/*static*/ void _CRhoAppAdapter::resetDBOnSyncUserChanged()
+	{
+		rho_connectclient_database_full_reset(false);
+	}	
+
+    /*static*/ bool  _CRhoAppAdapter::callCallbackOnSyncUserChanged()
+    {
+        return false; 
+    }
+}
+
+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;
+}
+
+	void alert_show_status(const char* szTitle, const char* szMessage, const char* szHide)
+	{
+	}
+	
+	const char* get_app_build_config_item(const char* key) 
+	{
+		return 0;
+	}
+
+    const char* rho_webview_execute_js(const char* js, int index){ return "";}
+    const char* rho_webview_execute_js_sync(const char* js, int index){ return "";}
+
+    int  rho_ruby_is_started(){return 0;}
+    int rho_webview_active_tab(){return 0;}
+}
+
+namespace rho{
+namespace sync{
+
+     CClientRegister::CClientRegister(){}
+     CClientRegister::~CClientRegister(){}
+     void CClientRegister::SetSslVerifyPeer(boolean b){}
+     bool CClientRegister::GetSslVerifyPeer(){return true;}
+    
+     CClientRegister* CClientRegister::Get(){ if (!m_pInstance){ m_pInstance = new CClientRegister();} return m_pInstance;}
+    
+     void CClientRegister::Stop(){}
+     void CClientRegister::run(){}
+
+
+    void CClientRegister::setRhoconnectCredentials(const String& user, const String& pass, const String& session){}
+    void CClientRegister::dropRhoconnectCredentials(const String& session,const String& clientID){}
+    
+
+
+    
+CClientRegister* CClientRegister::m_pInstance = 0;
+
+}
+}