rhoconnect-client 5.5.0

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

@@ -0,0 +1,213 @@
+/*------------------------------------------------------------------------
+* (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
+
+#include "common/RhoStd.h"
+#include "common/IRhoClassFactory.h"
+#include "common/RhoMutexLock.h"
+#include "net/INetRequest.h"
+#include "ISyncProtocol.h"
+
+#include "SyncSource.h"
+#include "SyncNotify.h"
+#include "db/DBAdapter.h"
+#include "logging/RhoLog.h"
+
+namespace rho {
+namespace sync {
+
+class CSyncEngine : public net::IRhoSession
+{
+    DEFINE_LOGCLASS;
+public:
+    enum ESyncState{ esNone, esSyncAllSources, esSyncSource, esSearch, esStop, esExit };
+	enum EBulkSyncState { ebsNotSynced = 0, ebsSynced = 1, ebsLoadBlobs = 2 };
+
+    struct CSourceID
+    {
+        String m_strName;
+        int m_nID;
+
+        CSourceID(int id, const String& strName ){ m_nID = id; m_strName = strName; }
+        CSourceID(const String& strName ){ m_strName = strName; }
+
+        String toString()const;
+        boolean isEqual(CSyncSource& src)const;
+    };
+
+    class CSourceOptions
+    {
+        common::CMutex m_mxSrcOptions;
+        HashtablePtr<int, Hashtable<String,String>* > m_hashSrcOptions;
+    public:
+        void setProperty(int nSrcID, const char* szPropName, const char* szPropValue);
+        String getProperty(int nSrcID, const char* szPropName);
+        boolean getBoolProperty(int nSrcID, const char* szPropName);
+        int getIntProperty(int nSrcID, const char* szPropName);
+		void clearProperties();
+    };
+
+private:
+    VectorPtr<CSyncSource*> m_sources;
+    NetRequest m_NetRequest, m_NetRequestClientID;
+    common::CAutoPtr<ISyncProtocol> m_SyncProtocol;
+    ESyncState m_syncState;
+    String     m_clientID;
+    common::CMutex m_mxLoadClientID, m_mxSessionID;
+    String m_strSession;
+    CSyncNotify m_oSyncNotify;
+    boolean m_bStopByUser;
+    int m_nSyncPageSize;
+	boolean m_bNoThreaded;
+    int m_nErrCode;
+    String m_strError;
+    boolean m_bIsSearch, m_bIsSchemaChanged;
+    static CSourceOptions m_oSourceOptions;
+
+    net::CNetRequestWrapper getNetClientID(){ return getNetRequest(&m_NetRequestClientID); }
+
+public:
+    CSyncEngine();
+    ~CSyncEngine(void){}
+
+    static CSourceOptions& getSourceOptions(){ return m_oSourceOptions; }
+    net::CNetRequestWrapper getNet(){ return getNetRequest(&m_NetRequest); }
+
+    void doSyncAllSources(const String& strQueryParams, boolean bSyncOnlyChangedSources);
+    void doSyncSource(const CSourceID& oSrcID, const String& strQueryParams);
+    void doSearch(rho::Vector<rho::String>& arSources, String strParams, const String& from,  boolean bSearchSyncChanges, int nProgressStep);
+
+    void login(String name, String password, const CSyncNotification& oNotify);
+    boolean isLoggedIn();
+    String loadSession();
+    void logout();
+    void logout_int();
+
+	void setSyncServer(const char* syncserver);
+    String getSyncServer() const;
+
+    void setState(ESyncState eState){ m_syncState = eState; }
+    ESyncState getState()const{ return m_syncState; }
+    boolean isSearch()const{ return m_bIsSearch; }
+    boolean isContinueSync()const{ return m_syncState != esExit && m_syncState != esStop; }
+	boolean isSyncing()const{ return m_syncState == esSyncAllSources || m_syncState == esSyncSource || m_syncState == esSearch; }
+    void stopSync(){ if (isContinueSync()){ setState(esStop); m_NetRequest.cancel();m_NetRequestClientID.cancel();} }
+    void stopSyncByUser(){ m_bStopByUser = true; stopSync(); }
+    void exitSync(){ setState(esExit); m_NetRequest.cancel(); m_NetRequestClientID.cancel();}
+    boolean isStoppedByUser(){ return m_bStopByUser; }
+    void setSslVerifyPeer(boolean b);
+    bool getSslVerifyPeer();
+
+//private:
+    String getClientID()const{ return m_clientID; }
+    void setSession(String strSession){m_strSession=strSession;}
+    boolean isSessionExist(){ return m_strSession.length() > 0; }
+
+    void setSchemaChanged(boolean bChanged){ m_bIsSchemaChanged = bChanged; }
+    boolean isSchemaChanged(){ return m_bIsSchemaChanged; }
+//IRhoSession
+    virtual const String& getSession()
+    { 
+        synchronized(m_mxSessionID){
+            return m_strSession;
+        }
+    }
+    virtual const String& getContentType(){ return getProtocol().getContentType();}
+
+    void loadAllSources();
+    void prepareSync(ESyncState eState, const CSourceID* oSrcID);
+
+    VectorPtr<CSyncSource*>& getSources(){ return m_sources; }
+    //int getStartSource();
+    String loadClientID();
+    String readClientID();
+    String requestClientIDByNet();
+    boolean resetClientIDByNet(const String& strClientID);//throws Exception
+    void doBulkSync();//throws Exception
+
+    CSyncNotify& getNotify(){ return m_oSyncNotify; }
+    ISyncProtocol& getProtocol(){ return *m_SyncProtocol; }
+
+    CSyncSource* findSourceByName(const String& strSrcName);
+	CSyncSource* findSourceById(int srcId);
+
+
+    int getSyncPageSize() { return m_nSyncPageSize; }
+    void setSyncPageSize(int nPageSize){ m_nSyncPageSize = nPageSize; }
+
+    boolean isNoThreadedMode(){ return m_bNoThreaded; }
+    void setNonThreadedMode(boolean b){m_bNoThreaded = b;}
+
+    void applyChangedValues(db::CDBAdapter& db);
+private:
+    
+    bool recoverSearch( const String& strUrl, const String& strBody, int& errorCode, String& strError, int nProgressStep );
+
+    CSyncSource* findSource(const CSourceID& oSrcID);
+
+    void loadBulkPartition(const String& strPartition);
+    String makeBulkDataFileName(String strDataUrl, String strDbPath, String strExt);
+    db::CDBAdapter& getUserDB(){ return db::CDBAdapter::getUserDB(); }
+    db::CDBAdapter& getDB(const String& strPartition){ return db::CDBAdapter::getDB(strPartition.c_str()); }
+
+    void initProtocol();
+    void processServerSources(String strSources);
+    void checkSourceAssociations();
+
+    void syncOneSource(int i, const String& strQueryParams, boolean bSyncOnlyIfChanged);
+    void syncAllSources(const String& strQueryParams, boolean bSyncOnlyChangedSources);
+	
+	boolean processBlobs();
+	void loadBulkPartitions();
+
+    friend class CSyncSource;
+};
+
+}
+}

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

@@ -0,0 +1,737 @@
+/*------------------------------------------------------------------------
+* (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 "SyncNotify.h"
+#include "SyncEngine.h"
+//#include "net/URI.h"
+#include "common/RhoFilePath.h"
+#include "common/RhoAppAdapter.h"
+#include "common/RhodesApp.h"
+#include "json/JSONIterator.h"
+
+#ifndef RHO_NO_RUBY
+    #include "rubyext/WebView.h"
+#endif
+
+namespace rho {
+namespace sync {
+IMPLEMENT_LOGCLASS(CSyncNotify,"Sync");
+using namespace rho::net;
+using namespace rho::common;
+using namespace rho::db;
+
+common::CAutoPtr<CObjectNotification> CSyncNotify::m_pObjectNotify;
+common::CMutex CSyncNotify::m_mxObjectNotify;
+
+void CSyncNotify::addObjectNotify(int nSrcID, const String& strObject)
+{
+    synchronized(m_mxObjectNotify)
+    {
+        Hashtable<String,int>* phashObject = m_hashSrcIDAndObject.get(nSrcID);
+        if ( phashObject == null )
+        {
+            phashObject = new Hashtable<String,int>();
+            m_hashSrcIDAndObject.put( nSrcID, phashObject );
+        }
+
+        Hashtable<String,int>& hashObject = *phashObject;
+        hashObject.put(strObject,enNone);
+    }
+}
+
+void CSyncNotify::addObjectNotify(const String& strSrcName, const String& strObject )
+{
+    synchronized(m_mxObjectNotify)
+    {
+        m_strSingleObjectSrcName = strSrcName;
+        m_strSingleObjectID = strObject[0] == '{' ? strObject.substr(1,strObject.length()-2) : strObject ;
+    }
+}
+
+void CSyncNotify::cleanObjectNotifications()
+{
+    synchronized(m_mxObjectNotify)
+    {
+        m_strSingleObjectSrcName = "";
+        m_strSingleObjectID = "";
+        m_hashSrcIDAndObject.clear();
+    }
+}
+
+void CSyncNotify::cleanCreateObjectErrors()
+{
+    synchronized(m_mxObjectNotify)
+    {
+        m_hashCreateObjectErrors.clear();
+    }
+}
+
+void CSyncNotify::processSingleObject()
+{
+    if ( m_strSingleObjectSrcName.length() == 0 )
+        return;
+
+    CSyncSource* pSrc = getSync().findSourceByName(m_strSingleObjectSrcName);
+    if ( pSrc )
+    {
+        int nSrcID = pSrc->getID();
+        addObjectNotify(nSrcID,m_strSingleObjectID);
+    }
+
+    m_strSingleObjectSrcName = "";
+    m_strSingleObjectID = "";
+}
+
+void CSyncNotify::fireObjectsNotification()
+{
+	Hashtable<String, String> result;
+	Hashtable<String, Hashtable<String,String> > l2Result;
+	Hashtable<String, String> hashDeleted,hashUpdated,hashCreated;
+
+    {
+        synchronized(m_mxObjectNotify)
+
+        if ( !m_pObjectNotify)
+            return;
+
+        for (HashtablePtr<int, Hashtable<String,int>* >::iterator it = m_hashSrcIDAndObject.begin();  it != m_hashSrcIDAndObject.end(); ++it )
+        {
+            int nSrcID = it->first;
+            Hashtable<String,int>& hashObject = *(it->second);
+            for ( Hashtable<String,int>::iterator itObject = hashObject.begin();  itObject != hashObject.end(); ++itObject )
+            {
+                int nNotifyType = itObject->second;
+                if (nNotifyType == enNone)
+                    continue;
+                //This is slow operation
+/*
+                if ( nNotifyType == enDelete )
+                {
+                    //TODO: get db for source
+                    IDBResult res = getDB().executeSQL("SELECT object FROM object_values where object=? LIMIT 1 OFFSET 0", itObject->first );
+                    if ( !res.isEnd() )
+                        nNotifyType = enUpdate;    
+                }
+*/
+                Hashtable<String,String>* pHash = 0;
+                switch(nNotifyType)
+                {
+                case enDelete:
+                    pHash = &hashDeleted;
+                    break;
+                case enUpdate:
+                    pHash = &hashUpdated;
+                    break;
+                case enCreate:
+                    pHash = &hashCreated;
+                    break;
+                }
+				
+                if (pHash != 0) {
+                    pHash->put( itObject->first, convertToStringA(nSrcID) );
+                }
+
+                hashObject.put(itObject->first, enNone);
+            }
+        }
+
+        if ( (hashDeleted.size() + hashCreated.size() + hashUpdated.size() ) == 0 )
+            return;
+    }
+	
+	l2Result.put("created",hashCreated);
+	l2Result.put("updated",hashUpdated);
+	l2Result.put("deleted",hashDeleted);
+
+	callNotify( CSyncNotification(m_pObjectNotify->m_callbackData,false), result, &l2Result );
+}
+
+void CSyncNotify::onObjectChanged(int nSrcID, const String& strObject, int nType)
+{
+    synchronized(m_mxObjectNotify)
+    {
+        processSingleObject();
+
+        Hashtable<String,int>* phashObject = m_hashSrcIDAndObject.get(nSrcID);
+        if ( phashObject == null )
+            return;
+
+        Hashtable<String,int>& hashObject = *phashObject;
+        if( hashObject.containsKey(strObject) )
+            hashObject.put(strObject,nType);
+    }
+}
+
+void CSyncNotify::addCreateObjectError(int nSrcID, const String& strObject, const String& strError)
+{
+    synchronized(m_mxObjectNotify)
+    {
+        Hashtable<String,String>* phashErrors = m_hashCreateObjectErrors.get(nSrcID);
+        if ( phashErrors == null )
+        {
+            phashErrors = new Hashtable<String,String>();
+            m_hashCreateObjectErrors.put( nSrcID, phashErrors );
+        }
+
+        Hashtable<String,String>& hashErrors = *phashErrors;
+        hashErrors.put(strObject,strError);
+    }
+}
+
+void CSyncNotify::appendCreateObjectErrorInfo(int nSrcID, Hashtable< String, Hashtable<String, String> >& result )
+{
+    String strBody = "";
+
+    synchronized(m_mxObjectNotify)
+    {
+        Hashtable<String,String>* phashErrors = m_hashCreateObjectErrors.get(nSrcID);
+		
+		
+        if ( phashErrors == null )
+            return ;
+
+        Hashtable<String,String>& hashErrors = *phashErrors;
+		
+        result.put("create_error",hashErrors);
+
+        hashErrors.clear();
+    }
+}
+
+void CSyncNotify::setObjectNotification(CObjectNotification* pNotify)
+{ 
+    synchronized(m_mxObjectNotify)
+    {
+        m_pObjectNotify = pNotify; 
+    }
+}
+
+CObjectNotification* CSyncNotify::getObjectNotification()
+{
+    synchronized(m_mxObjectNotify)
+    {
+        return m_pObjectNotify;
+    }
+}
+
+void CSyncNotify::onSyncSourceEnd( int nSrc, VectorPtr<CSyncSource*>& sources )
+{
+    CSyncSource& src = *sources.elementAt(nSrc);
+
+/*    if ( getSync().getState() == CSyncEngine::esStop && src.m_nErrCode != RhoAppAdapter.ERR_NONE )
+    {
+		CSyncNotification* pSN = getSyncNotifyBySrc(&src);
+		if ( pSN != null )
+			fireSyncNotification(&src, true, src.m_nErrCode, "");
+		else
+			fireAllSyncNotifications(true, src.m_nErrCode, src.m_strError, "" );
+    }
+    else*/
+        fireSyncNotification(&src, true, src.m_nErrCode, "");
+
+    cleanCreateObjectErrors();
+}
+
+void CSyncNotify::setSyncNotification(int source_id, CSyncNotification* pNotify )
+{
+    LOG(INFO) + "Set notification. Source ID: " + source_id + ";" + (pNotify ? pNotify->toString() : "");
+
+	if ( source_id == -1 )
+	{
+		synchronized(m_mxSyncNotifications)
+        {
+            m_pAllNotification = pNotify;
+        }
+	}else
+	{
+        synchronized(m_mxSyncNotifications)
+        {
+            m_mapSyncNotifications.put( source_id, pNotify );
+        }
+    }
+}
+
+CSyncNotification::CSyncNotification(const apiGenerator::CMethodResult& callbackData, boolean bRemoveAfterFire) :
+    m_callbackData(callbackData), m_cCallback(null), m_cCallbackData(null), m_bRemoveAfterFire(bRemoveAfterFire)
+{
+//    if ( m_callbackData.strUrl.length() > 0 )
+//        m_callbackData.strUrl = RHODESAPPBASE().canonicalizeRhoUrl(m_callbackData.strUrl);
+}
+
+CSyncNotification::~CSyncNotification()
+{
+    if ( m_cCallbackData )
+		rho_free_callbackdata(m_cCallbackData);
+}
+	
+String CSyncNotification::toString()const
+{
+	if ( m_cCallback )
+		return "C_Callback";
+	
+	String strRes = "Url :";
+//	strRes += m_strUrl;
+	strRes += "; Params: ";
+//	strRes += m_strParams;
+	return strRes;
+}
+    
+CObjectNotification::CObjectNotification(const apiGenerator::CMethodResult& callbackData) :
+   m_callbackData(callbackData), m_cCallback(null), m_cCallbackData(null)
+{
+}
+
+CObjectNotification::~CObjectNotification()
+{
+    if ( m_cCallbackData )
+        rho_free_callbackdata(m_cCallbackData);
+}
+
+String CObjectNotification::toString()const
+{
+    if ( m_cCallback )
+        return "C_Callback";
+    
+    String strRes = "Url :";
+//    strRes += m_callbackData.strUrl;
+    return strRes;
+}
+
+void CSyncNotify::setSearchNotification(CSyncNotification* pNotify )
+{
+    LOG(INFO) + "Set search notification." + (pNotify ? pNotify->toString() : "");
+    synchronized(m_mxSyncNotifications)
+    {
+        m_pSearchNotification = pNotify;
+    }
+}
+
+void CSyncNotify::showStatusPopup(const String& status)
+{
+    LOG(INFO) + "Status: "+status;
+
+    if ( m_strStatusHide.length() == 0 )
+        m_strStatusHide = RhoAppAdapter.getMessageText("hide");
+
+    if ( status.length() > 0 )
+        alert_show_status("", status.c_str(), m_strStatusHide.c_str());
+}
+
+void CSyncNotify::reportSyncStatus(String status, int error, String strDetails) 
+{
+	synchronized(m_mxSyncNotifications)
+	{    	
+    	if (/*m_syncStatusListener != null && */(isReportingEnabled() || error == RhoAppAdapter.ERR_SYNCVERSION) ) {
+    		
+    		if ( error == RhoAppAdapter.ERR_SYNCVERSION )
+            {
+    			status = RhoAppAdapter.getErrorText(error);
+                showStatusPopup(status);
+            }
+    		else if ( isReportingEnabled() )
+    		{
+	    		if ( strDetails.length() == 0 && error != RhoAppAdapter.ERR_NONE)
+	    			strDetails = RhoAppAdapter.getErrorText(error);
+	    		status += (strDetails.length() > 0 ? RhoAppAdapter.getMessageText("details") + strDetails: "");
+
+        	    //m_syncStatusListener.reportStatus( status, error);
+                showStatusPopup(status);
+    		}
+    	}
+	}
+}
+
+void CSyncNotify::fireBulkSyncNotification( boolean bFinish, String status, String partition, int nErrCode )
+{
+    if ( getSync().getState() == CSyncEngine::esExit )
+		return;
+
+	if( nErrCode != RhoAppAdapter.ERR_NONE)
+	{
+		String strMessage = RhoAppAdapter.getMessageText("sync_failed_for") + "bulk.";
+		reportSyncStatus(strMessage,nErrCode,"");
+	}
+	
+	Hashtable<String,String> params;
+	params.put("partition",partition);
+	params.put("bulk_status",status);
+	params.put("sync_type","bulk");
+
+    doFireSyncNotification( null, bFinish, nErrCode, "", &params, 0 );
+}
+
+
+void CSyncNotify::fireAllSyncNotifications( boolean bFinish, int nErrCode, String strError/*, String strServerError*/ )
+{
+    if ( getSync().getState() == CSyncEngine::esExit )
+		return;
+
+    synchronized(m_mxSyncNotifications)
+    {
+        CSyncNotification* pSN = getSyncNotifyBySrc(null);    
+        if ( pSN != null )
+            doFireSyncNotification( null, bFinish, nErrCode, strError, 0, 0/*strServerError*/ );
+    }
+}
+
+
+void CSyncNotify::fireSyncNotification( CSyncSource* src, boolean bFinish, int nErrCode, String strMessage)
+{
+    if ( getSync().getState() == CSyncEngine::esExit )
+		return;
+	
+	if( strMessage.length() > 0 || nErrCode != RhoAppAdapter.ERR_NONE)
+	{
+		if ( !getSync().isSearch() )
+        {
+			if ( src != null && strMessage.length() == 0 )
+				strMessage = RhoAppAdapter.getMessageText("sync_failed_for") + (*src).getName() + ".";
+			
+            reportSyncStatus(strMessage,nErrCode, (src != null ? (*src).m_strError : "") );
+        }
+	}
+
+    doFireSyncNotification(src, bFinish, nErrCode, "", 0, 0 );
+}
+
+CSyncNotification* CSyncNotify::getSyncNotifyBySrc(CSyncSource* src)
+{
+    CSyncNotification* pSN = null;
+	if ( getSync().isSearch() )
+		pSN = m_pSearchNotification;
+	else
+    {
+        if ( src != null )
+		    pSN = m_mapSyncNotifications.get( (*src).getID());
+
+        if ( pSN == null )
+            pSN = m_pAllNotification;
+    }
+
+	if ( pSN == null && !getSync().isNoThreadedMode() )
+        return null;
+
+    return pSN != null ? pSN : &m_emptyNotify;
+}
+
+void CSyncNotify::fireSyncNotification2( CSyncSource* src, boolean bFinish, int nErrCode, const Hashtable<String,String>& serverErrors)
+{
+    doFireSyncNotification(src, bFinish, nErrCode, "", 0, &serverErrors);
+}
+
+void CSyncNotify::doFireSyncNotification( CSyncSource* src, boolean bFinish, int nErrCode, String strError, const Hashtable<String,String>* params, const Hashtable<String,String>* pServerErrors)
+{
+	if ( getSync().isStoppedByUser() )
+		return;
+
+    CSyncNotification* pSN;
+
+	Hashtable<String, String> result;
+	Hashtable<String, Hashtable<String,String> > errorsL2;
+	
+    boolean bRemoveAfterFire = bFinish;
+    {
+        synchronized(m_mxSyncNotifications)
+        {
+            pSN = getSyncNotifyBySrc(src);
+	        if ( pSN == null )
+                return;
+			
+			if ( params != 0 ) {
+				result = *params;
+			}else {
+				result.put("sync_type","incremental");
+			}
+
+            if ( src != null )
+            {
+				result.put("total_count", convertToStringA( (*src).getTotalCount()));
+				result.put("processed_count", convertToStringA( (*src).getTotalCount()));
+				result.put("cumulative_count", convertToStringA( (*src).getCurPageCount()));
+				result.put("source_id", convertToStringA( (*src).getID()));
+				result.put("source_name", (*src).getName());
+			}
+
+			String status;
+            if ( bFinish )
+            {
+                if ( nErrCode == RhoAppAdapter.ERR_NONE )
+                {
+                    if ( getSync().isSchemaChanged() )
+                        status = "schema_changed";
+                    else
+                        status = (src == null && ( (params==0) || params->size()==0 ) ) ? "complete" : "ok";
+                }
+	            else
+	            {
+                    if ( getSync().isStoppedByUser() )
+                        nErrCode = RhoAppAdapter.ERR_CANCELBYUSER;
+
+					status = "error";
+					
+					result.put("error_code", convertToStringA(nErrCode) );
+					
+					String error;
+					if ( strError.length() > 0 ) {
+                        error = strError;
+					} else if ( src != null ) {
+                        error = (*src).m_strError;
+					}
+					
+					result.put("error_message",error);
+					
+					if ( pServerErrors != 0 ) {
+						errorsL2.put("server_errors",*pServerErrors);
+					}
+				}
+
+                if ( src != null ) {
+                    appendCreateObjectErrorInfo( (*src).getID(), errorsL2 );
+				}
+            } else {
+        	    status = "in_progress";
+			}
+						   
+			result.put("status",status);
+						   			
+            bRemoveAfterFire = bRemoveAfterFire && pSN->m_bRemoveAfterFire;
+        }
+    }
+    LOG(INFO) + "Fire notification. Source : " + (src != null ? (*src).getName():"") + "; " + pSN->toString();
+	
+    if ( callNotify(*pSN, result, &errorsL2 ) || bRemoveAfterFire)
+        clearNotification(src);
+}
+
+const String& CSyncNotify::getNotifyBody()
+{
+    const static String emptyBody = String();
+    if ( m_arNotifyBody.size() == 0 )
+        return emptyBody;
+
+    if ( isFakeServerResponse() )
+        return m_arNotifyBody[0];
+
+    return m_arNotifyBody[m_arNotifyBody.size()-1];
+}
+	
+	
+String CSyncNotify::notifyParamToStr( const Hashtable<String,String>& result, const Hashtable< String, Hashtable< String, String > >* l2Hashes) {
+
+	String ret = "";
+    
+    struct JSONCreator {
+        static String& addCommaIfNeeded( String& result ) {
+            result = String_trimRight(result);
+            if ( (result.length()>0) && !(String_endsWith(result,"[" ) || String_endsWith(result,"{") ) ) { //|| String_endsWith(result,",")
+                result += ",";
+            }
+            return result;
+        }
+        
+        static String& addNode( const String& key, const String& value, bool jsonValue, String& result ) {
+            addCommaIfNeeded(result);
+            //String quote = jsonValue?"":"\"";
+            result += "\"" + key + "\":" + (jsonValue?value: rho::json::CJSONEntry::quoteValue(value));
+            return result;
+        }
+        
+        static String& addNode( const Hashtable<String,String>& objects, const Hashtable< String, Hashtable< String, String > >* l2Hashes, String& result, bool skipComma = false ) {
+            if ( !skipComma ) {
+                addCommaIfNeeded(result);
+            }
+            
+            //TODO : fix object notify with empty hash
+            if ( (objects.size()==0) && ((l2Hashes==0) || (l2Hashes->size()==0)) ) {
+                return result;
+            }
+            
+            result += "{";
+
+            for ( Hashtable<String,String>::const_iterator it = objects.begin(); it != objects.end(); ++it ) {
+                String key = it->first;
+                bool jsonValue = false;
+                if ( String_endsWith(it->first,"-json")) {
+                    jsonValue = true;
+                    key = key.substr( 0, key.length() - 5 );
+                }
+                addNode( key, it->second, jsonValue, result );
+            }
+            
+            if ( l2Hashes !=0 ) {
+                if ( l2Hashes->size() > 0 ) {
+                    addCommaIfNeeded(result);
+                }
+
+                for ( Hashtable< String, Hashtable< String, String > >::const_iterator it = l2Hashes->begin(); it != l2Hashes->end(); ++it ) {
+                    //addCommaIfNeeded(result);
+                    result += "\"" + it->first + "\":";
+                    addNode( it->second, 0, result, true );
+                }
+            }
+            
+            result += "}";
+            
+            return result;
+        }
+        
+    };
+    
+    JSONCreator::addNode( result, l2Hashes, ret );
+    
+	return ret;
+}
+
+
+boolean CSyncNotify::callNotify(const CSyncNotification& oNotify, const Hashtable<String, String>& result, const Hashtable<String,Hashtable<String,String> >* l2Hashes )
+{
+	apiGenerator::CMethodResult cb = oNotify.m_callbackData;
+    
+    String strBody = notifyParamToStr( result, l2Hashes );
+	
+    if ( getSync().isNoThreadedMode() )
+    {
+        m_arNotifyBody.addElement( strBody );
+        return false;
+    }
+	
+    if ( oNotify.m_cCallback )
+    {
+        m_isInsideCallback = true;        
+        int nRet = (*oNotify.m_cCallback)(strBody.c_str(), oNotify.m_cCallbackData);
+        m_isInsideCallback = false;
+        return nRet == 1;
+    }
+
+	m_isInsideCallback = true;
+
+	cb.setJSON(strBody);
+
+    
+	m_isInsideCallback = false;
+
+	return true;
+}
+
+void CSyncNotify::clearNotification(CSyncSource* src)
+{
+    LOG(INFO) + "Clear notification. Source : " + (src != null ? (*src).getName() : "");
+
+    synchronized(m_mxSyncNotifications)
+    {
+        if ( getSync().isSearch() )
+            m_pSearchNotification = null;
+        else if ( src != null )
+            m_mapSyncNotifications.remove( (*src).getID());
+    }
+}
+
+void CSyncNotify::clearSyncNotification(int source_id) 
+{
+	LOG(INFO) + "Clear notification. Source ID: " + source_id;
+	
+    synchronized(m_mxSyncNotifications)
+    {
+        if ( source_id == -1 )//Clear all
+            m_pAllNotification = null;
+        else
+            m_mapSyncNotifications.remove(source_id);
+    }
+}
+
+void CSyncNotify::cleanLastSyncObjectCount()
+{
+    synchronized(m_mxSyncNotifications)
+    {
+        m_hashSrcObjectCount.clear();
+    }
+}
+
+int CSyncNotify::incLastSyncObjectCount(int nSrcID)
+{
+    int nCount = 0;
+    synchronized(m_mxSyncNotifications)
+    {
+        nCount = m_hashSrcObjectCount.get(nSrcID)+1;
+        m_hashSrcObjectCount.put(nSrcID,nCount);
+    }
+
+    return nCount;
+}
+
+int CSyncNotify::getLastSyncObjectCount(int nSrcID)
+{
+    int nCount = 0;
+    synchronized(m_mxSyncNotifications)
+    {
+        nCount = m_hashSrcObjectCount.get(nSrcID);
+    }
+
+    return nCount;
+}
+
+void CSyncNotify::callLoginCallback(const CSyncNotification& oNotify, int nErrCode, String strMessage)
+{
+	if ( getSync().isStoppedByUser() )
+		return;
+	
+	Hashtable<String, String> result;
+	String strErrorCode = convertToStringA(nErrCode);
+	String strEncodedMessage = strMessage;//URI::urlEncode(strMessage);
+	
+	result.put("error_code", strErrorCode);
+	result.put("error_message", strEncodedMessage);
+
+    LOG(INFO) + "Login callback: " + oNotify.toString() + ". Error code: "+ strErrorCode + ". Message: " + strEncodedMessage;
+
+    callNotify(oNotify,result);
+}
+
+}
+}
+