rhoconnect-client 5.5.0

data/ext/rhoconnect-client/ext/shared/RhoConnectClientImpl.h

@@ -0,0 +1,60 @@
+#include "generated/cpp/RhoConnectClientBase.h"
+#include "sync/SyncThread.h"
+
+namespace rho {
+	
+class RhoConnectClientImpl : public CRhoConnectClientSingletonBase
+{
+private:
+	sync::CSyncThread* getSyncThread() const { return sync::CSyncThread::getInstance(); }
+	sync::CSyncEngine& getSyncEngine() const { return sync::CSyncThread::getSyncEngine(); }
+public:
+
+
+    RhoConnectClientImpl();
+	
+	virtual void getUserName(rho::apiGenerator::CMethodResult& oResult);
+    virtual void getPollInterval(rho::apiGenerator::CMethodResult& oResult);
+    virtual void setPollInterval( int value, rho::apiGenerator::CMethodResult& oResult);
+    virtual void getSyncServer(rho::apiGenerator::CMethodResult& oResult);
+    virtual void setSyncServer( const rho::String& value, rho::apiGenerator::CMethodResult& oResult);
+    virtual void getBulksyncState( rho::apiGenerator::CMethodResult& oResult);
+    virtual void setBulksyncState( int state, rho::apiGenerator::CMethodResult& oResult);
+    virtual void getPageSize(rho::apiGenerator::CMethodResult& oResult);
+    virtual void setPageSize( int value, rho::apiGenerator::CMethodResult& oResult);
+    virtual void getThreadedMode(rho::apiGenerator::CMethodResult& oResult);
+    virtual void setThreadedMode( bool value, rho::apiGenerator::CMethodResult& oResult);
+    virtual void getShowStatusPopup(rho::apiGenerator::CMethodResult& oResult);
+    virtual void setShowStatusPopup( bool value, rho::apiGenerator::CMethodResult& oResult);
+    virtual void getSslVerifyPeer(rho::apiGenerator::CMethodResult& oResult);
+    virtual void setSslVerifyPeer( bool value, rho::apiGenerator::CMethodResult& oResult);
+    virtual void isLoggedIn(rho::apiGenerator::CMethodResult& oResult);
+    virtual void isSyncing(rho::apiGenerator::CMethodResult& oResult);
+
+    virtual void search( const rho::Hashtable<rho::String, rho::String>& args, rho::apiGenerator::CMethodResult& oResult);
+    virtual void doSync( bool showStatusPopup,  const rho::String& queryParams,  bool syncOnlyChangedSources, rho::apiGenerator::CMethodResult& oResult);
+    virtual void doSyncSource( const rho::String& sourceName,  bool showStatusPopup,  const rho::String& queryParams, rho::apiGenerator::CMethodResult& oResult);
+    virtual void login( const rho::String& login,  const rho::String& password, rho::apiGenerator::CMethodResult& oResult);
+    virtual void logout(rho::apiGenerator::CMethodResult& oResult);
+    virtual void stopSync(rho::apiGenerator::CMethodResult& oResult);
+    virtual void setNotification( const rho::String& sourceName, rho::apiGenerator::CMethodResult& oResult);
+    virtual void clearNotification( const rho::String& sourceName, rho::apiGenerator::CMethodResult& oResult);
+    virtual void setObjectNotification(rho::apiGenerator::CMethodResult& oResult);
+    virtual void addObjectNotify( const rho::String& sourceName,  const rho::String& object, rho::apiGenerator::CMethodResult& oResult);
+    virtual void cleanObjectNotify(rho::apiGenerator::CMethodResult& oResult);
+    virtual void getLastSyncObjectCount( const rho::String& sourceName, rho::apiGenerator::CMethodResult& oResult);
+    virtual void setSourceProperty( const rho::String& sourceName,  const rho::String& propertyName,  const rho::String& propertyValue, rho::apiGenerator::CMethodResult& oResult);
+    virtual void getSourceProperty( const rho::String& sourceName,  const rho::String& propertyName, rho::apiGenerator::CMethodResult& oResult);
+	
+private:
+	void handleSyncResult(rho::apiGenerator::CMethodResult& oResult);
+
+
+};
+
+
+ 
+
+}
+
+extern "C" void Init_RhoConnectClient_API();

data/ext/rhoconnect-client/ext/shared/RhoConnectClientSingletonImpl.h

@@ -0,0 +1,53 @@
+#include "IRhoConnectClient.h"
+
+namespace rho {
+
+
+	class RhoConnectClientSingletonImpl : public IRhoConnectClient
+	{
+		virtual ~IRhoConnectClientSingleton(){}
+		
+		virtual void GetUserName(rho::apiGenerator::CMethodResult& oResult);
+		virtual void OnSyncCreateError( const rho::StringW& srcName,  const rho::Vector<rho::StringW>& objects,  const rho::StringW& action, rho::apiGenerator::CMethodResult& oResult);
+		virtual void PushChanges( const rho::StringW& srcName, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void OnSyncUpdateError( const rho::StringW& srcName,  const rho::Vector<rho::StringW>& objects,  const rho::StringW& action,  const rho::StringW& rollbackData, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void OnSyncDeleteError( const rho::StringW& srcName,  const rho::Vector<rho::StringW>& objects,  const rho::StringW& action, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void Search( const rho::Hashtable<rho::StringW, rho::StringW>& args, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void DoSync( bool showStatusPopup,  const rho::StringW& queryParams,  bool syncOnlyChangedSources, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void DoSyncSource( int64 sourceId,  bool showStatusPopup,  const rho::StringW& queryParams, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void DoSearch( const rho::Vector<rho::StringW>& arSources,  const rho::StringW& from,  const rho::StringW& params,  bool syncChanges,  int64 nProgressStep,  const rho::StringW& callback,  const rho::StringW& callbackParams, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void Login( const rho::StringW& login,  const rho::StringW& password,  const rho::StringW& callback, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void LoggedIn(rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void Logout(rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void StopSync(rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetNotification( int64 sourceId,  const rho::StringW& url,  const rho::StringW& params, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void ClearNotification( int64 sourceId, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetPollInterval( int64 interval, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void GetPollInterval(rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetSyncServer( const rho::StringW& syncServer, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void GetSourceAttributes( const rho::StringW& partition,  int64 sourceId, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetObjectNotifyUrl( const rho::StringW& url, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void AddObjectNotify( int64 sourceId,  const rho::StringW& object, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void CleanObjectNotify(rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void GetLastSyncObjectCount( int64 sourceId, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void GetBulksyncState( rho::apiGenerator::CMethodResult& oResult) = 0;
+    virtual void SetBulksyncState( const int state, rho::apiGenerator::CMethodResult& oResult) = 0;		
+		virtual void GetPageSize(rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetPageSize( int64 pageSize, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetThreadedMode( bool threadedModeEnabled, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void EnableStatusPopup( bool statusPopupEnabled, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetSourceProperty( int64 sourceId,  const rho::StringW& propertyName,  const rho::StringW& propertyValue, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void GetSourceProperty( int64 sourceId,  const rho::StringW& propertyName, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void SetSslVerifyPeer( bool verifyPeer, rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void IsSyncing(rho::apiGenerator::CMethodResult& oResult) = 0;
+		virtual void RegisterPush(rho::apiGenerator::CMethodResult& oResult) = 0;
+		
+		virtual void addCommandToQueue(rho::common::IRhoRunnable* pFunctor) = 0;
+		virtual void callCommandInThread(rho::common::IRhoRunnable* pFunctor) = 0;
+		
+	};
+	
+extern "C" void Init_RhoConnectClient_API();
+
+
+}

data/ext/rhoconnect-client/ext/shared/initRhoconnectClient.cpp

@@ -0,0 +1,207 @@
+
+#include "sync/RhoconnectClientManager.h"
+#include "sync/ILoginListener.h"
+#include "sync/SyncThread.h"
+#include "sync/ClientRegister.h"
+#include "RhoConnectClientImpl.h"
+#include "common/RhodesApp.h"
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "initRhoconnectClient"
+
+class RhoConnectClientRhodesInterfaceImpl : public rho::sync::IRhoconnectClient {
+public:
+	virtual ~RhoConnectClientRhodesInterfaceImpl() {}
+	
+	virtual void doSyncSourceByName( const char* srcName ) {
+		rho_sync_doSyncSourceByName( srcName );
+	}
+	
+	virtual void doSyncAllSources( int show_status_popup, const char* query_params, int sync_only_changed_sources ) {
+		rho_sync_doSyncAllSources(show_status_popup, query_params, sync_only_changed_sources );
+	}
+	
+	virtual void clientRegisterCreate( const char* szDevicePin ) {
+		rho::sync::CClientRegister::Create(szDevicePin);
+	}
+
+	virtual void clientRegisterDestroy() {
+		rho::sync::CClientRegister::Destroy();
+	}
+
+        virtual bool clientRegisterHaveInstance() {
+		return rho::sync::CClientRegister::getInstance() != 0;
+	}
+
+	virtual void clientRegisterCreate( ) {
+		rho::sync::CClientRegister::Create();
+	}
+
+	virtual void clientRegisterAddLoginListener( rho::sync::ILoginListener* listener ) {
+		rho::sync::CClientRegister::AddLoginListener(listener);
+	}
+
+        virtual void clientRegisterSetDevicePin(const char* pin ) {
+		rho::sync::CClientRegister::Get()->setDevicehPin(pin);
+	}
+	
+	virtual void rho_sync_addobjectnotify_bysrcname(const char* szSrcName, const char* szObject) {
+		rho::sync::CSyncThread::getSyncEngine().getNotify().addObjectNotify(szSrcName, szObject);
+	}
+	
+	virtual const rho::String& clientRegisterGetDevicePin() {
+		return rho::sync::CClientRegister::Get()->getDevicePin();
+	}
+	
+	virtual rho::String syncEnineReadClientID() {
+		return rho::sync::CSyncThread::getSyncEngine().readClientID();
+	}
+	
+	virtual rho::net::IRhoSession* getRhoSession() {
+		return &(rho::sync::CSyncThread::getSyncEngine());
+	}
+	
+	virtual void syncEngineApplyChangedValues(rho::db::CDBAdapter& db) {
+		rho::sync::CSyncThread::getSyncEngine().applyChangedValues(db);
+	}
+	
+	virtual void syncThreadCreate() {
+		rho::sync::CSyncThread::Create();
+	}
+	
+	virtual void syncThreadDestroy() {
+		rho::sync::CSyncThread::Destroy();
+	}
+	
+	virtual bool haveSyncThread() {
+		return rho::sync::CSyncThread::getInstance() != 0;
+	}
+	
+	virtual unsigned int syncThreadGetThreadID() {
+		rho::sync::CSyncThread* t = rho::sync::CSyncThread::getInstance();
+		return (t!=0)?t->getThreadID():((unsigned int)-1);
+		
+	}
+	
+	virtual bool syncEngineNotifyIsReportingEnabled() {
+		return rho::sync::CSyncThread::getInstance()->getSyncEngine().getNotify().isReportingEnabled();
+	}
+		
+	virtual int logged_in() {
+		return rho_sync_logged_in();
+	}
+	
+	virtual unsigned long login(const char* loginStr, const char* password, const char* callback) {
+        // commented out because it will cause a crash: callback should be a MethodResult, not char*
+        //return rho_sync_login(login, password, callback);
+        return 0;
+	}
+	
+	virtual void logout() {
+		rho_sync_logout();
+	}
+	
+	virtual void stop() {
+		rho_sync_stop();
+	}
+
+	virtual void set_bulksyncstate( int new_state ) {
+		rho_sync_set_bulksyncstate(new_state);
+	}
+
+	virtual bool has_bulksyncstate() {
+		return rho_sync_has_bulksyncstate();
+	}
+
+	virtual int get_bulksyncstate() {
+		return rho_sync_get_bulksyncstate();
+	}
+	
+	virtual int set_pollinterval( int interval ) {
+		return rho_sync_set_pollinterval(interval);
+	}
+
+	virtual int get_pollinterval() {
+		return rho_sync_get_pollinterval();
+	}
+	
+	virtual void set_syncserver( const char* syncserver ) {
+		rho_sync_set_syncserver(syncserver);
+	}
+	
+	virtual int get_pagesize() {
+		return rho_sync_get_pagesize();
+	}
+	
+	virtual void set_pagesize(int nPageSize) {
+		rho_sync_set_pagesize(nPageSize);
+	}
+	
+	virtual int get_lastsync_objectcount(int nSrcID) {
+		return rho_sync_get_lastsync_objectcount(nSrcID);
+	}
+
+	virtual int issyncing() {
+		return rho_sync_issyncing();
+	}
+	
+	virtual void enable_status_popup(int b) {
+		rho_sync_enable_status_popup(b);
+	}
+	
+	virtual void set_threaded_mode(int b) {
+		rho_sync_set_threaded_mode(b);
+	}
+	
+	virtual void register_push() {
+		rho_sync_register_push();
+	}
+	
+	virtual void set_ssl_verify_peer(int b) {
+		rho_sync_set_ssl_verify_peer(b);
+	}
+	
+	virtual void setobjectnotify_url(const char* szUrl) {
+		rho_sync_setobjectnotify_url(szUrl);
+	}
+	
+	virtual void cleanobjectnotify() {
+		rho_sync_cleanobjectnotify();
+	}
+	
+	virtual void clear_notification(int srcID) {
+		rho_sync_clear_notification(srcID);
+	}
+
+	virtual void set_source_property(int srcID, const char* propName, const char* propValue) {
+		rho_sync_set_source_property(srcID, propName, propValue);
+	}
+
+
+};
+
+RhoConnectClientRhodesInterfaceImpl g_client;
+
+namespace rho {
+
+class RhoConnectClientFactory : public CRhoConnectClientFactoryBase
+{
+public:
+    RhoConnectClientFactory(){}
+	
+    IRhoConnectClientSingleton* createModuleSingleton(){ return new RhoConnectClientImpl(); }
+};
+
+}
+
+extern "C" {
+
+void initRhoconnectClient() {
+	RHODESAPP().getExtManager().requireRubyFile("RhoConnectClient");
+
+	rho::RhoConnectClientFactory::setInstance( new rho::RhoConnectClientFactory() );
+	
+	rho::sync::RhoconnectClientManager::setRhoconnectClientImpl( &g_client );
+}
+
+}

data/ext/rhoconnect-client/ext/shared/rhoconnectclient.c

@@ -0,0 +1,18 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+	
+#include "logging/RhoLog.h"
+
+extern void Init_RhoConnectClient_API(void);
+extern void initRhoconnectClient();
+
+// this method executed once on start of program
+void Init_Rhoconnectclient_extension(void) {
+	Init_RhoConnectClient_API();
+	initRhoconnectClient();
+}
+
+#ifdef __cplusplus
+} //extern "C"
+#endif

data/ext/rhoconnect-client/ext/shared/sync/ClientRegister.cpp

@@ -0,0 +1,398 @@
+/*------------------------------------------------------------------------
+* (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 "ClientRegister.h"
+#include "SyncThread.h"
+#include "sync/ILoginListener.h"
+#include "common/RhoConf.h"
+#include "common/RhodesApp.h"
+#include "System.h"
+#include "Push.h"
+
+rho::String rho_sysimpl_get_phone_id();
+
+namespace rho{
+namespace sync{
+
+using namespace rho::common;
+using namespace rho::db;
+
+static const int THREAD_WAIT_TIMEOUT = 10;
+
+
+IMPLEMENT_LOGCLASS(CClientRegister,"ClientRegister");
+
+CClientRegister* CClientRegister::m_pInstance = 0;
+bool CClientRegister::s_sslVerifyPeer = true;
+VectorPtr<ILoginListener*> CClientRegister::s_loginListeners;
+	
+/*static*/ CClientRegister* CClientRegister::Get()
+{
+    if (!m_pInstance)
+    {
+        m_pInstance = new CClientRegister();
+    }
+    return m_pInstance;
+}
+
+/*static*/ CClientRegister* CClientRegister::Create()
+{
+    LOG(TRACE) + "Starting ClientRegister";
+    Get()->startUp();
+    return m_pInstance;
+}
+
+/*static*/ CClientRegister* CClientRegister::Create(const String& devicePin)
+{
+    Get()->setDevicehPin(devicePin);
+    return m_pInstance;
+}
+
+/*static*/ void CClientRegister::Stop()
+{
+    if(m_pInstance)
+    {
+        m_pInstance->doStop();
+    }
+}
+
+/*static*/ void CClientRegister::Destroy()
+{
+    if ( m_pInstance )
+        delete m_pInstance;
+
+    m_pInstance = 0;
+}
+
+/*static*/ void CClientRegister::SetSslVerifyPeer(boolean b)
+{
+    s_sslVerifyPeer = b;
+    if (m_pInstance)
+        m_pInstance->m_NetRequest.setSslVerifyPeer(b);
+}
+
+bool CClientRegister::GetSslVerifyPeer()
+{
+    return s_sslVerifyPeer;
+}
+
+/*static*/void CClientRegister::AddLoginListener(ILoginListener* listener)
+{
+    s_loginListeners.addElement(listener);
+}
+
+CClientRegister::CClientRegister() : m_nPollInterval(POLL_INTERVAL_SECONDS), m_state(stRegister)
+{
+    m_NetRequest.setSslVerifyPeer(s_sslVerifyPeer);
+}
+
+CClientRegister::~CClientRegister()
+{
+    doStop();
+    m_pInstance = null;
+}
+void CClientRegister::setRhoconnectCredentials(const String& user, const String& pass, const String& session)
+{
+    LOG(INFO) + "New Sync credentials - user: " + user + ", sess: " + session;
+    
+    setState(stRegister);
+
+    notifyLoggedIn(user,pass,session);
+    
+    startUp();
+}
+
+void CClientRegister::dropRhoconnectCredentials(const String& session,const String& clientID)
+{
+    LOG(INFO) + "Dropping credentials - sess: " + session;
+    
+    setState(stUnregister);
+    
+    m_unregisterSession = session;
+    m_unregisterClientID = clientID;
+
+    notifyLoggedOut(session);
+    
+    startUp();
+}
+    
+void CClientRegister::notifyLoggedIn(const String& user, const String& pass, const String& session)
+{
+    for(VectorPtr<ILoginListener*>::iterator I = s_loginListeners.begin(); I != s_loginListeners.end(); ++I)
+    {
+        (*I)->onLogin(user, pass, session);
+    }
+}
+
+void CClientRegister::notifyLoggedOut(const String& session)
+{
+    for(VectorPtr<ILoginListener*>::iterator I = s_loginListeners.begin(); I != s_loginListeners.end(); ++I)
+    {
+        (*I)->onLogout(session);
+    }
+}
+
+void CClientRegister::setDevicehPin(const String& pin)
+{
+    m_strDevicePin = pin;
+
+    if (pin.length() > 0)
+    {
+        startUp();
+    } else
+    {
+        doStop();
+    }
+}
+
+void CClientRegister::startUp()
+{
+    if ( RHOCONF().getString("syncserver").length() > 0 )
+    {
+        LOG(INFO) + "Starting ClientRegister...";
+
+        start(epLow);
+        stopWait();
+    }
+}
+
+void CClientRegister::run()
+{
+    unsigned i = 0;
+    LOG(INFO)+"ClientRegister is started";
+	while(!isStopping()) 
+	{
+        i++;
+        LOG(INFO)+"Try to (un)register: " + i;
+        if ( CSyncThread::getInstance() != null )
+		{
+            EnState state = getState();
+			if ( (stRegister==state) && doRegister(CSyncThread::getSyncEngine()) )
+			{
+			    LOG(INFO)+"Registered: " + i;
+				break;
+			} else if  ( (stUnregister==state) && doUnregister(CSyncThread::getSyncEngine()) ) {
+                LOG(INFO)+"Unregistered: " + i;
+				break;
+            }
+		} else
+		    LOG(INFO)+"SyncThread is not ready";
+		
+		LOG(INFO)+"Waiting for "+ m_nPollInterval+ " sec to try again to register client";
+		wait(m_nPollInterval*1000);
+	}
+    LOG(INFO)+"ClientRegister thread shutdown";
+}
+
+String CClientRegister::getRegisterBody(const String& strClientID)
+{
+    String strPushType = rho::push::CPushManager::getInstance()->getDefaultID();
+    if(strPushType == "rhoconnect")
+    {
+        strPushType = "rhoconnect_push";
+    }
+
+    int port = RHOCONF().getInt("push_port");
+
+	String body = CSyncThread::getSyncEngine().getProtocol().getClientRegisterBody( strClientID, m_strDevicePin,
+		port > 0 ? port : DEFAULT_PUSH_PORT, rho_rhodesapp_getplatform(), rho::System::getPhoneId(),
+		                strPushType);
+
+	LOG(INFO)+"getRegisterBody() BODY is: " + body;
+	return body;
+}
+    
+String CClientRegister::getUnregisterBody(const String& strClientID)
+{    
+	String body = CSyncThread::getSyncEngine().getProtocol().getClientRegisterBody( strClientID, "", 0, "", "", "" );
+	LOG(INFO)+"getUnregisterBody() BODY is: " + body;
+	return body;
+}
+
+boolean CClientRegister::doRegister(CSyncEngine& oSync)
+{
+    String session = oSync.loadSession();
+    if ( session.length() == 0 )
+    {
+        m_nPollInterval = POLL_INTERVAL_INFINITE;
+        LOG(INFO)+"Session is empty, do register later";
+        return false;
+    }
+    
+    if ( m_strDevicePin.length() == 0 )
+    {
+        notifyLoggedIn("","",session);
+        m_nPollInterval = POLL_INTERVAL_INFINITE;
+        LOG(INFO)+"Device PUSH pin is empty, do register later";
+        return false;
+    }
+    m_nPollInterval = POLL_INTERVAL_SECONDS;
+
+	String client_id = oSync.loadClientID();
+	if ( client_id.length() == 0 )
+	{
+        LOG(WARNING)+"Sync client_id is empty, do register later";
+		return false;
+	}
+    
+    IDBResult res = CDBAdapter::getUserDB().executeSQL("SELECT token,token_sent from client_info");
+    if ( !res.isEnd() ) {
+		String token = res.getStringByIdx(0); 
+		int token_sent = res.getIntByIdx(1) && !RHOCONF().getBool("register_push_at_startup");
+                
+		if ( m_strDevicePin.compare(token) == 0 && token_sent > 0 ) 
+		{
+			//token in db same as new one and it was already send to the server
+			//so we do nothing
+            
+			return true; 
+		}
+    }
+    
+	String strBody = getRegisterBody(client_id);
+    NetResponse resp = getNet().pushData( oSync.getProtocol().getClientRegisterUrl(client_id), strBody, &oSync );
+	if( resp.isOK() )
+    {
+        CDBAdapter::getUserDB().executeSQL("UPDATE client_info SET token_sent=?, token=?", 1, m_strDevicePin );
+		LOG(INFO)+"Registered client sucessfully...";
+        
+        return true;
+
+    }
+
+	LOG(WARNING)+"Network error: "+ resp.getRespCode();
+	return false;
+}
+    
+boolean CClientRegister::doUnregister(CSyncEngine& oSync)
+{
+    String session = m_unregisterSession;
+    if ( session.length() == 0 )
+    {
+        m_unregisterSession = "";
+        m_unregisterClientID = "";
+
+        LOG(INFO)+"Session is empty, don't need to unregister";
+        return true;
+    }    
+
+    m_nPollInterval = POLL_INTERVAL_SECONDS;
+
+	String client_id = m_unregisterClientID;
+	if ( client_id.length() == 0 )
+	{
+        m_unregisterSession = "";
+        m_unregisterClientID = "";
+
+        LOG(WARNING)+"Sync client_id is empty, don't need to unregister";
+		return true;
+	}
+        
+    String strBody = getUnregisterBody(client_id);    
+    LOG(INFO)+"Unregistered client with body = " + strBody;
+    
+    class UnregisterSession : public net::IRhoSession {
+        String m_session;
+        String m_contentType;
+    public:
+        UnregisterSession(const String& session, const String& contentType) : m_session(session), m_contentType(contentType) {}
+      	virtual void logout() {}
+        virtual const String& getSession() {
+            return m_session;
+        }
+        virtual const String& getContentType() {
+            return m_contentType;
+        }
+    };
+    
+    UnregisterSession unregSession(session, oSync.getProtocol().getContentType() );
+    
+    NetResponse resp = getNet().pushData( oSync.getProtocol().getClientRegisterUrl(client_id), strBody, &unregSession );
+	if( resp.isOK() )
+    {
+        m_unregisterSession = "";
+        m_unregisterClientID = "";
+
+        CDBAdapter::getUserDB().executeSQL("UPDATE client_info SET token_sent=?", 0 );
+		LOG(INFO)+"Unregistered client sucessfully...";
+        
+        return true;
+        
+    }
+    
+	LOG(WARNING)+"Network error: "+ resp.getRespCode();
+	return false;
+}
+    
+void CClientRegister::setState( EnState st ) {
+    synchronized(m_mxStateAccess)
+    {
+        m_state = st;
+    }
+}
+    
+CClientRegister::EnState CClientRegister::getState() {
+    EnState state = stRegister;
+    synchronized(m_mxStateAccess)
+    {
+        state = m_state;
+    }
+
+    return state;
+}
+
+void CClientRegister::doStop()
+{
+    LOG(INFO) + "Stopping ClientRegister...";
+
+    m_NetRequest.cancel();
+    stop(WAIT_BEFOREKILL_SECONDS);
+}
+
+}
+}