rhodes 2.0.0.beta7 → 2.0.0.beta8

data/platform/iphone/RhoLib/RhoLib.xcodeproj/project.pbxproj

@@ -48,6 +48,8 @@
 		5C98174C0FBC4FCE002597A5 /* AutoPointer.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C9817490FBC4FCE002597A5 /* AutoPointer.h */; };
 		5C98174D0FBC4FCE002597A5 /* InputStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C98174A0FBC4FCE002597A5 /* InputStream.h */; };
 		5C98174E0FBC4FCE002597A5 /* irhoclassfactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C98174B0FBC4FCE002597A5 /* irhoclassfactory.h */; };
+		5CA2DE9011B01EF000B868D5 /* ThreadQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5CA2DE8E11B01EF000B868D5 /* ThreadQueue.cpp */; };
+		5CA2DE9111B01EF000B868D5 /* ThreadQueue.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CA2DE8F11B01EF000B868D5 /* ThreadQueue.h */; };
 		5CBD462A1087399700107D0D /* URI.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5CBD46271087399700107D0D /* URI.cpp */; };
 		5CBD462B1087399700107D0D /* URI.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CBD46281087399700107D0D /* URI.h */; };
 		5CCD7EBC116CE2D5005E6CA3 /* AppMenu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5CCD7EBA116CE2D5005E6CA3 /* AppMenu.cpp */; };
@@ -111,6 +113,8 @@
 		5C9817490FBC4FCE002597A5 /* AutoPointer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AutoPointer.h; path = ../../shared/common/AutoPointer.h; sourceTree = SOURCE_ROOT; };
 		5C98174A0FBC4FCE002597A5 /* InputStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = InputStream.h; path = ../../shared/common/InputStream.h; sourceTree = SOURCE_ROOT; };
 		5C98174B0FBC4FCE002597A5 /* irhoclassfactory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = irhoclassfactory.h; path = ../../shared/common/irhoclassfactory.h; sourceTree = SOURCE_ROOT; };
+		5CA2DE8E11B01EF000B868D5 /* ThreadQueue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadQueue.cpp; path = ../../shared/common/ThreadQueue.cpp; sourceTree = SOURCE_ROOT; };
+		5CA2DE8F11B01EF000B868D5 /* ThreadQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ThreadQueue.h; path = ../../shared/common/ThreadQueue.h; sourceTree = SOURCE_ROOT; };
 		5CBD46271087399700107D0D /* URI.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = URI.cpp; path = ../../shared/net/URI.cpp; sourceTree = SOURCE_ROOT; };
 		5CBD46281087399700107D0D /* URI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = URI.h; path = ../../shared/net/URI.h; sourceTree = SOURCE_ROOT; };
 		5CCD7EBA116CE2D5005E6CA3 /* AppMenu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AppMenu.cpp; path = ../../shared/common/AppMenu.cpp; sourceTree = SOURCE_ROOT; };
@@ -196,6 +200,8 @@
 		5C7162600F8B7DEE0096B6AA /* common */ = {
 			isa = PBXGroup;
 			children = (
+				5CA2DE8E11B01EF000B868D5 /* ThreadQueue.cpp */,
+				5CA2DE8F11B01EF000B868D5 /* ThreadQueue.h */,
 				5CCD7EBA116CE2D5005E6CA3 /* AppMenu.cpp */,
 				5CCD7EBB116CE2D5005E6CA3 /* AppMenu.h */,
 				BDD11ECB113664E700349BE3 /* rhoparams.c */,
@@ -328,6 +334,7 @@
 				5C59BF4E115B4BC300E96ADE /* unzip.h in Headers */,
 				5C2F10BC116146930054AC80 /* RhoRuby.h in Headers */,
 				5CCD7EBD116CE2D5005E6CA3 /* AppMenu.h in Headers */,
+				5CA2DE9111B01EF000B868D5 /* ThreadQueue.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -396,6 +403,7 @@
 				5C59BF4D115B4BC300E96ADE /* unzip.cpp in Sources */,
 				5C2F10BB116146930054AC80 /* RhoRuby.cpp in Sources */,
 				5CCD7EBC116CE2D5005E6CA3 /* AppMenu.cpp in Sources */,
+				5CA2DE9011B01EF000B868D5 /* ThreadQueue.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

data/platform/shared/common/IRhoClassFactory.h

@@ -8,6 +8,7 @@ namespace net{
 
 struct ICallbackObject
 {
+    virtual ~ICallbackObject(){};
     virtual unsigned long getObjectValue() = 0;
 };
 

data/platform/shared/common/RhodesApp.cpp

@@ -92,6 +92,7 @@ void CRhodesApp::run()
 
     LOG(INFO) + "Starting sync engine...";
     rho_sync_create();
+
     LOG(INFO) + "RhoRubyInitApp...";
     RhoRubyInitApp();
 
@@ -130,7 +131,7 @@ void CRhodesApp::stopApp()
         stop(2000);
     }
 
-    rho_asynchttp_destroy();
+    net::CAsyncHttp::Destroy();
 }
 
 class CRhoCallbackCall :  public common::CRhoThread
@@ -577,7 +578,11 @@ unsigned long CRhodesApp::getCallbackObject(int nIndex)
     if ( !pCallbackObject )
         return rho_ruby_get_NIL();
 
-    return pCallbackObject->getObjectValue();
+    unsigned long valRes = pCallbackObject->getObjectValue();
+
+    delete pCallbackObject;
+
+    return valRes;
 }
 
 void CRhodesApp::setPushNotification(String strUrl, String strParams )

data/platform/shared/common/ThreadQueue.cpp

@@ -0,0 +1,110 @@
+#include "ThreadQueue.h"
+
+namespace rho {
+namespace common {
+
+CThreadQueue::CThreadQueue(common::IRhoClassFactory* factory) : CRhoThread(factory)
+{
+    m_nPollInterval = QUEUE_POLL_INTERVAL_SECONDS;
+    m_bNoThreaded = false;
+
+    m_ptrFactory = factory;
+}
+
+CThreadQueue::~CThreadQueue(void)
+{
+}
+
+void CThreadQueue::addQueueCommand(CQueueCommand* pCmd)
+{ 
+    LOG(INFO) + "addCommand: " + pCmd->toString();
+	{
+        synchronized(m_mxStackCommands);
+
+		boolean bExist = false;
+        if ( isSkipDuplicateCmd() )
+        {
+		    for ( int i = 0; i < (int)m_stackCommands.size(); i++ )
+		    {
+			    if ( m_stackCommands.get(i)->equals(*pCmd) )
+			    {
+				    bExist = true;
+				    break;
+			    }
+		    }
+        }
+
+		if ( !bExist )
+    		m_stackCommands.add(pCmd);
+	}
+
+    if ( isNoThreadedMode()  )
+        processCommands();
+    else
+	    stopWait(); 
+}
+
+void CThreadQueue::run()
+{
+	LOG(INFO) + "Starting main routine...";
+
+	int nLastPollInterval = getLastPollInterval();
+	while( !isStopped() )
+	{
+        unsigned int nWait = m_nPollInterval > 0 ? m_nPollInterval : QUEUE_POLL_INTERVAL_INFINITE;
+
+        if ( m_nPollInterval > 0 && nLastPollInterval > 0 )
+        {
+            int nWait2 = m_nPollInterval - nLastPollInterval;
+            if ( nWait2 <= 0 )
+                nWait = QUEUE_STARTUP_INTERVAL_SECONDS;
+            else
+                nWait = nWait2;
+        }
+
+        if ( nWait >= 0 && !isStopped() && isNoCommands() )
+		{
+            LOG(INFO) + "ThreadQueue blocked for " + nWait + " seconds...";
+            wait(nWait);
+        }
+        nLastPollInterval = 0;
+
+        if ( !isStopped() )
+    		processCommands();
+	}
+}
+
+boolean CThreadQueue::isNoCommands()
+{
+	boolean bEmpty = false;
+	synchronized(m_mxStackCommands)
+    {		
+		bEmpty = m_stackCommands.isEmpty();
+	}
+
+	return bEmpty;
+}
+
+void CThreadQueue::processCommands()//throws Exception
+{
+	while(!isStopped() && !isNoCommands())
+	{
+		common::CAutoPtr<CQueueCommand> pCmd = null;
+    	{
+        	synchronized(m_mxStackCommands);
+    		pCmd = (CQueueCommand*)m_stackCommands.removeFirst();
+    	}
+		
+		processCommand(pCmd);
+	}
+}
+
+void CThreadQueue::setPollInterval(int nInterval)
+{ 
+    m_nPollInterval = nInterval; 
+    stopWait();
+}
+
+};
+};
+

data/platform/shared/common/ThreadQueue.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#ifdef __cplusplus
+
+#include "logging/RhoLog.h"
+#include "common/RhoThread.h"
+#include "common/RhoMutexLock.h"
+#include "common/IRhoClassFactory.h"
+
+namespace rho {
+namespace common {
+
+class CThreadQueue : public common::CRhoThread
+{
+protected:
+    static const unsigned int QUEUE_POLL_INTERVAL_SECONDS  = 300;
+    static const unsigned int QUEUE_POLL_INTERVAL_INFINITE  = (unsigned int)(-1);
+    static const unsigned int QUEUE_STARTUP_INTERVAL_SECONDS  = 10;
+
+public:
+    DEFINE_BASELOGCLASS
+
+    struct CQueueCommand
+    {
+        virtual ~CQueueCommand(){};
+        virtual boolean equals(const CQueueCommand& cmd) = 0;
+        virtual String toString() = 0;
+    };
+
+private:
+
+    common::CAutoPtr<common::IRhoClassFactory> m_ptrFactory;
+	int           m_nPollInterval;
+   	common::CMutex m_mxStackCommands;
+	LinkedListPtr<CQueueCommand*> m_stackCommands;
+
+    boolean m_bNoThreaded;
+public:
+    CThreadQueue(common::IRhoClassFactory* factory);
+
+    ~CThreadQueue(void);
+
+    virtual void addQueueCommand(CQueueCommand* pCmd);
+	virtual void run();
+
+	void setPollInterval(int nInterval);
+    int  getPollInterval()const{ return m_nPollInterval;}
+
+    boolean isNoThreadedMode(){ return m_bNoThreaded; }
+    void setNonThreadedMode(bool b){m_bNoThreaded = b;}
+
+    common::IRhoClassFactory* getFactory(){ return m_ptrFactory; }
+protected:
+    virtual int getLastPollInterval(){ return 0;}
+    virtual void processCommand(CQueueCommand* pCmd) = 0;
+    virtual boolean isSkipDuplicateCmd() { return false; }
+
+    virtual void processCommands();
+
+    boolean isNoCommands();
+};
+
+}
+}
+#endif //__cplusplus
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+	
+#ifdef __cplusplus
+};
+#endif //__cplusplus
+
+

data/platform/shared/logging/RhoLogCat.h

@@ -25,4 +25,8 @@ extern rho::LogCategory __rhoCurrentCategory;
 #define IMPLEMENT_LOGCLASS(classname, name) \
     rho::LogCategory classname::__rhoCurrentCategory = name
 
+#define DEFINE_BASELOGCLASS rho::LogCategory __rhoCurrentCategory;\
+    rho::LogCategory getLogCategory(){return __rhoCurrentCategory;}\
+    void setLogCategory(const rho::LogCategory& cat){__rhoCurrentCategory = cat;}
+
 #endif //_RHOLOGCAT_H_

data/platform/shared/net/AsyncHttp.cpp

@@ -11,79 +11,52 @@ namespace net
 {
 
 IMPLEMENT_LOGCLASS(CAsyncHttp, "AsyncHttp");
-common::CMutex CAsyncHttp::m_mxInstances;
-VectorPtr<CAsyncHttp*> CAsyncHttp::m_arInstances;
+CAsyncHttp* CAsyncHttp::m_pInstance = 0;
 
-extern "C" void header_iter(const char* szName, const char* szValue, void* pHash)
+/*static*/ CAsyncHttp* CAsyncHttp::Create()
 {
-    ((Hashtable<String,String>*)pHash)->put(szName, szValue);
+    if ( m_pInstance ) 
+        return m_pInstance;
+
+    m_pInstance = new CAsyncHttp( rho::common::createClassFactory());
+    return m_pInstance;
 }
 
-CAsyncHttp::CAsyncHttp(common::IRhoClassFactory* factory, EHttpCommands eCmd,
-    const char* url, unsigned long headers, const char* body,
-    const char* file_path,
-    const char* callback, const char* callback_params, boolean ssl_verify_peer) :  CRhoThread(factory)
+/*static*/void CAsyncHttp::Destroy()
 {
-    m_bFinished = false;
-    m_ptrFactory = factory;
-    m_strUrl = url != null ? url : "";
-    m_strBody = body != null ? body : "";
-    m_strFilePath = file_path != null ? file_path : "";
-    m_strCallback = callback != null ? callback : "";
-    m_strCallbackParams = callback_params != null ? callback_params : "";
-    m_eCmd = eCmd;
-    m_sslVerifyPeer = ssl_verify_peer;
-
-    rho_ruby_enum_strhash(headers, &header_iter, &m_mapHeaders);
-
-    addNewObject(this);
+    if ( m_pInstance )
+        delete m_pInstance;
 
-    if (m_strCallback.length()==0)
-        run();
-    else
-        start(epLow);
+    m_pInstance = 0;
 }
 
-void CAsyncHttp::cancel(boolean bWait)
+CAsyncHttp::CAsyncHttp(common::IRhoClassFactory* factory) : CThreadQueue(factory)
 {
-    {		
-    	synchronized(m_mxRequest)
+    CThreadQueue::setLogCategory(getLogCategory());
 
-        if (m_pNetRequest!=null && !m_pNetRequest->isCancelled() )
-            m_pNetRequest->cancel();
-    }
+    setPollInterval(QUEUE_POLL_INTERVAL_INFINITE);
 
-    if ( bWait )
-        stop(-1);
+    m_pCurCmd = null;
 }
 
-/*static*/ void CAsyncHttp::addNewObject(CAsyncHttp* pObj)
+CAsyncHttp::~CAsyncHttp(void)
 {
-	synchronized(m_mxInstances)
-    {
-        while(1)
-        {
-            int nToDelete = -1;
-            for (int i = 0; i < (int)m_arInstances.size(); i++ )
-            {
-                if ( m_arInstances.elementAt(i)->m_bFinished )
-                {
-                    nToDelete = i;
-                    break;
-                }
-            }
-
-            if (nToDelete==-1)
-                break;
-
-            m_arInstances.removeElementAt(nToDelete);
-        }
+    cancelRequest("*", true);
+    LOG(INFO) + "Thread shutdown";
+}
 
-        m_arInstances.addElement(pObj);
+void CAsyncHttp::addQueueCommand(CQueueCommand* pCmd)
+{
+    if ( ((CHttpCommand*)pCmd)->m_strCallback.length()==0)
+        processCommand(pCmd);
+    else
+    {
+        CThreadQueue::addQueueCommand(pCmd);
+        start(epLow);
     }
 }
 
-/*static*/ void CAsyncHttp::cancelRequest(const char* szCallback, boolean bWait)
+void CAsyncHttp::cancelRequest(const char* szCallback, boolean bWait)
 {
     if (!szCallback || !*szCallback )
     {
@@ -91,44 +64,68 @@ void CAsyncHttp::cancel(boolean bWait)
         return;
     }
 
-	synchronized(m_mxInstances)
-    {		
-        if ( *szCallback == '*')
-        {
-            for (int i = 0; i < (int)m_arInstances.size(); i++ )
-                m_arInstances.elementAt(i)->cancel(bWait);
-        }else
-        {
-            for (int i = 0; i < (int)m_arInstances.size(); i++ )
-            {
-                if ( m_arInstances.elementAt(i)->m_strCallback.compare(szCallback) == 0 )
-                    m_arInstances.elementAt(i)->cancel(bWait);    
-            }
-        }
-    }
+    if ( m_pCurCmd != null )
+        m_pCurCmd->cancel();
+
+    if ( bWait )
+        stop(-1);
+
+    //TODO: find command by callback and cancel it if current, remove if it is still in queue
 }
 
-void CAsyncHttp::run()
+void CAsyncHttp::processCommand(CQueueCommand* pCmd)
 {
-    LOG(INFO) + "RhoHttp thread start.";
+    m_pCurCmd = (CHttpCommand*)pCmd;
+    m_pCurCmd->execute();
+    m_pCurCmd = null;
+}
 
-    {		
-        synchronized(m_mxRequest)
-        m_pNetRequest = m_ptrFactory->createNetRequest();
-        m_pNetRequest->sslVerifyPeer(m_sslVerifyPeer);
-    }
+extern "C" void header_iter(const char* szName, const char* szValue, void* pHash)
+{
+    ((Hashtable<String,String>*)pHash)->put(szName, szValue);
+}
+
+CAsyncHttp::CHttpCommand::CHttpCommand(
+    EHttpCommands eCmd,
+    const char* url, unsigned long headers, const char* body,
+    const char* file_path,
+    const char* callback, const char* callback_params, boolean ssl_verify_peer)
+{
+    m_strUrl = url != null ? url : "";
+    m_strBody = body != null ? body : "";
+    m_strFilePath = file_path != null ? file_path : "";
+    m_strCallback = callback != null ? callback : "";
+    m_strCallbackParams = callback_params != null ? callback_params : "";
+    m_eCmd = eCmd;
+    m_sslVerifyPeer = ssl_verify_peer;
+
+    rho_ruby_enum_strhash(headers, &header_iter, &m_mapHeaders);
 
+    m_pNetRequest = CAsyncHttp::getInstance()->getFactory()->createNetRequest();
+    m_pNetRequest->sslVerifyPeer(m_sslVerifyPeer);
+
+}
+
+void CAsyncHttp::CHttpCommand::cancel()
+{
+    if (m_pNetRequest!=null && !m_pNetRequest->isCancelled() )
+        m_pNetRequest->cancel();
+}
+
+void CAsyncHttp::CHttpCommand::execute()
+{
+    INetResponse* resp = null;
     switch( m_eCmd )
     {
     case hcGet:
-        m_pNetResponse = m_pNetRequest->doRequest("GET", m_strUrl, m_strBody, null, &m_mapHeaders);
+        resp = m_pNetRequest->doRequest("GET", m_strUrl, m_strBody, null, &m_mapHeaders);
         break;
     case hcPost:
-        m_pNetResponse = m_pNetRequest->doRequest("POST", m_strUrl, m_strBody, null, &m_mapHeaders);
+        resp = m_pNetRequest->doRequest("POST", m_strUrl, m_strBody, null, &m_mapHeaders);
         break;
 
     case hcDownload:
-        m_pNetResponse = m_pNetRequest->pullFile(m_strUrl, m_strFilePath, null, &m_mapHeaders);
+        resp = m_pNetRequest->pullFile(m_strUrl, m_strFilePath, null, &m_mapHeaders);
         break;
 
     case hcUpload:
@@ -148,23 +145,24 @@ void CAsyncHttp::run()
                 arMultipartItems.addElement(pItem);
             }
 
-            m_pNetResponse = m_pNetRequest->pushMultipartData( m_strUrl, arMultipartItems, null, &m_mapHeaders );
+            resp = m_pNetRequest->pushMultipartData( m_strUrl, arMultipartItems, null, &m_mapHeaders );
             break;
         }
     }
 
     if ( !m_pNetRequest->isCancelled())
-    {
-        //processResponse(*m_pNetResponse);
-        callNotify(*m_pNetResponse,0);
-    }
+        callNotify(resp,0);
+}
 
-	LOG(INFO) + "RhoHttp thread end.";
+unsigned long CAsyncHttp::CHttpCommand::getRetValue()
+{
+    if ( m_strCallback.length() == 0 )
+        return rho_ruby_create_string(m_strResBody.c_str()); 
 
-    m_bFinished = true;
+    return rho_ruby_get_NIL();
 }
 
-String CAsyncHttp::makeHeadersString()
+String CAsyncHttp::CHttpCommand::makeHeadersString()
 {
     String strRes = "";
 
@@ -182,39 +180,10 @@ String CAsyncHttp::makeHeadersString()
     return strRes;
 }
 
-extern "C" VALUE rjson_tokener_parse(const char *str, char** pszError );
-unsigned long CAsyncHttp::getObjectValue()
-{ 
-    rho::net::INetResponse& resp = *m_pNetResponse;
-    if (resp.isOK())
-    {
-        String strContType = m_mapHeaders.get("content-type");
-        if ( strContType.find("application/json") != String::npos )
-        {
-            char* szError = 0;
-            unsigned long valBody = rjson_tokener_parse(resp.getCharData(), &szError);
-            if ( valBody != 0 )
-                return valBody;
-
-            LOG(ERROR) + "Incorrect json body.Error:" + (szError ? szError : "");
-            if ( szError )
-                free(szError);
-        }
-    }
-
-    return rho_ruby_create_string(resp.getCharData()); 
-}
-
-unsigned long CAsyncHttp::getRetValue()
+void CAsyncHttp::CHttpCommand::callNotify(rho::net::INetResponse* pResp, int nError )
 {
-    if ( m_strCallback.length() == 0 )
-        return rho_ruby_create_string(m_strResBody.c_str()); 
+    rho::net::INetResponse& resp = *pResp;
 
-    return rho_ruby_get_NIL();
-}
-
-void CAsyncHttp::callNotify(rho::net::INetResponse& resp, int nError )
-{
     m_strResBody = "rho_callback=1";
     m_strResBody += "&status=";
     if ( nError > 0 )
@@ -240,7 +209,8 @@ void CAsyncHttp::callNotify(rho::net::INetResponse& resp, int nError )
         if (strHeaders.length() > 0 )
             m_strResBody += "&" + strHeaders;
 
-        m_strResBody += "&" + RHODESAPP().addCallbackObject(this, "body");
+        m_strResBody += "&" + RHODESAPP().addCallbackObject(
+            new CAsyncHttpResponse(pResp, m_mapHeaders.get("content-type")), "body");
     }
 
     if ( m_strCallbackParams.length() > 0 )
@@ -248,12 +218,33 @@ void CAsyncHttp::callNotify(rho::net::INetResponse& resp, int nError )
 
     if ( m_strCallback.length() > 0 )
     {
-        common::CAutoPtr<INetRequest> pNetRequest = m_ptrFactory->createNetRequest();
-        String strFullUrl = pNetRequest->resolveUrl(m_strCallback);
-        NetResponse(resp1,pNetRequest->pushData( strFullUrl, m_strResBody, null ));
-        if ( !resp1.isOK() )
-            LOG(ERROR) + "AsyncHttp notification failed. Code: " + resp1.getRespCode() + "; Error body: " + resp1.getCharData();
+        String strFullUrl = m_pNetRequest->resolveUrl(m_strCallback);
+        m_pNetRequest->pushData( strFullUrl, m_strResBody, null );
+    }
+}
+
+CAsyncHttp::CAsyncHttpResponse::~CAsyncHttpResponse(){}
+
+extern "C" VALUE rjson_tokener_parse(const char *str, char** pszError );
+unsigned long CAsyncHttp::CAsyncHttpResponse::getObjectValue()
+{ 
+    rho::net::INetResponse& resp = *m_pNetResponse;
+    if (resp.isOK())
+    {
+        if ( m_strContentType.find("application/json") != String::npos )
+        {
+            char* szError = 0;
+            unsigned long valBody = rjson_tokener_parse(resp.getCharData(), &szError);
+            if ( valBody != 0 )
+                return valBody;
+
+            LOG(ERROR) + "Incorrect json body.Error:" + (szError ? szError : "");
+            if ( szError )
+                free(szError);
+        }
     }
+
+    return rho_ruby_create_string(resp.getCharData()); 
 }
 
 } // namespace net
@@ -265,36 +256,44 @@ using namespace rho::net;
 
 unsigned long rho_asynchttp_get(const char* url, unsigned long headers, const char* callback, const char* callback_params, int ssl_verify_peer)
 {
-    CAsyncHttp* pHttp = new CAsyncHttp(rho::common::createClassFactory(), CAsyncHttp::hcGet, url, headers, null, null, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::Create();
+
+    CAsyncHttp::CHttpCommand* pHttp = new CAsyncHttp::CHttpCommand(CAsyncHttp::hcGet, url, headers, null, null, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::getInstance()->addQueueCommand(pHttp);
     return pHttp->getRetValue();
 }
 
 unsigned long rho_asynchttp_post(const char* url, unsigned long headers, const char* body, const char* callback, const char* callback_params, int ssl_verify_peer)
 {
-    CAsyncHttp* pHttp = new CAsyncHttp(rho::common::createClassFactory(), CAsyncHttp::hcPost, url, headers, body!=null?body:"", null, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::Create();
+
+    CAsyncHttp::CHttpCommand* pHttp = new CAsyncHttp::CHttpCommand(CAsyncHttp::hcPost, url, headers, body!=null?body:"", null, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::getInstance()->addQueueCommand(pHttp);
     return pHttp->getRetValue();
 }
 
 unsigned long rho_asynchttp_downloadfile(const char* url, unsigned long headers, const char* file_path, const char* callback, const char* callback_params, int ssl_verify_peer)
 {
-    CAsyncHttp* pHttp = new CAsyncHttp(rho::common::createClassFactory(), CAsyncHttp::hcDownload, url, headers, "", file_path, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::Create();
+
+    CAsyncHttp::CHttpCommand* pHttp = new CAsyncHttp::CHttpCommand(CAsyncHttp::hcDownload, url, headers, "", file_path, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::getInstance()->addQueueCommand(pHttp);
     return pHttp->getRetValue();
 }
 
 unsigned long rho_asynchttp_uploadfile(const char* url, unsigned long headers, const char* body, const char* file_path, const char* callback, const char* callback_params, int ssl_verify_peer)
 {
-    CAsyncHttp* pHttp = new CAsyncHttp(rho::common::createClassFactory(), CAsyncHttp::hcUpload, url, headers, body, file_path, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::Create();
+
+    CAsyncHttp::CHttpCommand* pHttp = new CAsyncHttp::CHttpCommand(CAsyncHttp::hcUpload, url, headers, body, file_path, callback, callback_params, ssl_verify_peer!=0 );
+    CAsyncHttp::getInstance()->addQueueCommand(pHttp);
     return pHttp->getRetValue();
 }
 
 void rho_asynchttp_cancel(const char* cancel_callback)
 {
-    CAsyncHttp::cancelRequest(cancel_callback, false);
-}
-
-void rho_asynchttp_destroy()
-{
-    CAsyncHttp::cancelRequest("*", true);
+    if ( CAsyncHttp::getInstance() )
+        CAsyncHttp::getInstance()->cancelRequest(cancel_callback, false);
 }
 
 }