rhodes 2.3.2 → 2.4.0.beta.1

data/platform/shared/common/RhodesApp.h

@@ -33,6 +33,7 @@ private:
     common::CAutoPtr<net::CHttpServer> m_httpServer;
     CSplashScreen m_oSplashScreen;
     CAppMenu m_oAppMenu;
+    CRhoTimer m_oTimer;
 
     String m_strLoadingPagePath, m_strLoadingPngPath;
     String m_strStartUrl, m_strOptionsUrl, m_strRhobundleReloadUrl;//, m_strFirstStartUrl;
@@ -77,7 +78,6 @@ public:
     const String& getStartUrl();
     const String& getOptionsUrl();
     const String& getCurrentUrl(int index = 0);
-    //const String& getFirstStartUrl();
     boolean isOnStartPage();
 
 	const String& getLoadingPngPath(){return m_strLoadingPngPath;}
@@ -100,9 +100,11 @@ public:
     void callUiCreatedCallback();
     void callUiDestroyedCallback();
     void callPopupCallback(String strCallbackUrl, const String &id, const String &title);
+    boolean callTimerCallback(const String& strUrl, const String& strData);
 
     CAppMenu& getAppMenu (void) { return m_oAppMenu; }
     CSplashScreen& getSplashScreen(){return m_oSplashScreen;}
+    CRhoTimer&     getTimer(){ return m_oTimer; }
 
     boolean sendLog();
 
@@ -156,6 +158,7 @@ const char* rho_rhodesapp_getcurrenturl(int tabindex);
 
 const char* rho_rhodesapp_getloadingpagepath();
 const char* rho_rhodesapp_getblobsdirpath();
+const char* rho_rhodesapp_getapprootpath();
 	
 void rho_http_redirect(void* httpContext, const char* szUrl);
 void rho_http_senderror(void* httpContext, int nError, const char* szMsg);

data/platform/shared/common/StringConverter.h

@@ -19,18 +19,30 @@ template<typename T>  inline StringW convertToStringW( const T& value ){ return
 template<typename T>  inline void convertFromStringA( const char* szValue, T& value ){ value = szValue; }
 template<typename T>  inline String convertToStringA( const T& value ){ return value; }
 
-inline String convertToStringA( const wchar_t* szValue ){ 
+inline String convertToStringA( const wchar_t* szValue )
+{ 
     String res;
+    if ( !szValue || !*szValue )
+        return res;
+
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+    int nSize = WideCharToMultiByte(CP_UTF8, 0, szValue, -1, NULL, 0, NULL, NULL);
+    if ( nSize > 1 )
+    {
+        res.resize(nSize-1);
+        WideCharToMultiByte(CP_UTF8, 0, szValue, -1, &res[0], nSize, NULL, NULL);
+    }
+#else
     int nSize = wcstombs( NULL, szValue, 0 );
-    if ( nSize >= 0 ){
-        char* buf = new char[nSize+1];
-        int nRes = wcstombs( buf, szValue, nSize );
+    if ( nSize >= 0 )
+    {
+        res.resize(nSize);
+        int nRes = wcstombs( &res[0], szValue, nSize );
         if ( nRes >= 0 ){
-            buf[nRes] = 0;
-            res = buf; 
+            res[nRes] = 0;
         }
     }
-
+#endif
     return res;
 }
 
@@ -46,12 +58,26 @@ template<>  inline String convertToStringA<StringW>( const StringW& strValue ){
     return convertToStringA(strValue.c_str());
 }
 
-inline void convertToStringW( const char* szValue, StringW& res ){ 
+inline void convertToStringW( const char* szValue, StringW& res )
+{ 
+    if ( !szValue || !*szValue )
+        return;
+
 #ifdef OS_ANDROID
 	res = szValue;
 #else
-    int nSize = mbstowcs( NULL, szValue, 0 );
-    if ( nSize >= 0 ){
+
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+    int nSize = MultiByteToWideChar(CP_UTF8, 0, szValue, -1, NULL, 0);
+    if ( nSize > 1 )
+    {
+        res.resize(nSize-1);
+        MultiByteToWideChar(CP_UTF8, 0, szValue, -1, &res[0], nSize);
+    }
+#else
+    int nSize =mbstowcs( NULL, szValue, 0 );
+    if ( nSize >= 0 )
+    {
         res.resize(nSize);
         int nRes = mbstowcs( &res[0], szValue, nSize );
         if ( nRes >= 0 ){
@@ -59,6 +85,7 @@ inline void convertToStringW( const char* szValue, StringW& res ){
         }
     }
 #endif
+#endif
 }
 
 inline StringW convertToStringW( const String& str )

data/platform/shared/common/app_build_capabilities.h

@@ -0,0 +1,2 @@
+// WARNING! THIS FILE IS GENERATED AUTOMATICALLY! DO NOT EDIT IT MANUALLY!
+

data/platform/shared/common/rhoparams.cpp

@@ -5,11 +5,11 @@ namespace rho
 
 CRhoParams::CRhoParams(rho_param *p): m_pParams(p){}
 
-rho_param * CRhoParams::findHashParam(const char* name)
+const rho_param * CRhoParams::findHashParam(const char* name) const
 {
     if (m_pParams->type == RHO_PARAM_HASH)
     {
-        for (int i = 0; i < m_pParams->v.hash->size; ++i) 
+        for (int i = 0; i < m_pParams->v.hash->size; ++i)
         {
             if (strcasecmp(name, m_pParams->v.hash->name[i]) == 0)
                 return m_pParams->v.hash->value[i];
@@ -18,14 +18,27 @@ rho_param * CRhoParams::findHashParam(const char* name)
     return null;
 }
 
-String CRhoParams::getString(const char* szName)
+boolean CRhoParams::has(const char* name) const
+{
+    if (m_pParams->type == RHO_PARAM_HASH)
+    {
+        for (int i = 0; i < m_pParams->v.hash->size; ++i)
+        {
+            if (strcasecmp(name, m_pParams->v.hash->name[i]) == 0)
+                return true;
+        }
+    }
+    return false;
+}
+
+String CRhoParams::getString(const char* szName) const
 {
     return getString(szName, "");
 }
 
-String CRhoParams::getString(const char* szName, const char* szDefValue)
+String CRhoParams::getString(const char* szName, const char* szDefValue) const
 {
-    rho_param * value = findHashParam(szName);
+    const rho_param * value = findHashParam(szName);
     String strRes = value && value->v.string ? value->v.string : "";
     if (strRes.length() == 0 && szDefValue && *szDefValue)
         strRes = szDefValue;
@@ -33,20 +46,20 @@ String CRhoParams::getString(const char* szName, const char* szDefValue)
     return strRes;
 }
 
-void CRhoParams::getHash(const char* name, rho::Hashtable<rho::String,rho::String>& mapHeaders)
+void CRhoParams::getHash(const char* name, rho::Hashtable<rho::String,rho::String>& mapHeaders) const
 {
-    rho_param * hash = findHashParam(name);
+    const rho_param * hash = findHashParam(name);
     if (!hash || hash->type != RHO_PARAM_HASH)
         return;
 
-    for (int i = 0; i < hash->v.hash->size; ++i) 
+    for (int i = 0; i < hash->v.hash->size; ++i)
     {
         rho_param * value = hash->v.hash->value[i];
         mapHeaders.put( hash->v.hash->name[i], value->v.string );
     }
 }
 
-boolean CRhoParams::getBool(const char* name)
+boolean CRhoParams::getBool(const char* name) const
 {
 	String strValue = getString(name);
 	if ( strValue.length() == 0 )
@@ -64,12 +77,12 @@ void CRhoParams::free_params()
 CRhoParamArray::CRhoParamArray(CRhoParams& oParams, const char* name) : CRhoParams(oParams)
 {
     m_array = null;
-    rho_param * ar = findHashParam(name);
+    const rho_param * ar = findHashParam(name);
     if (ar != null && ar->type == RHO_PARAM_ARRAY)
         m_array = ar->v.array;
 }
 
-int CRhoParamArray::size()
+int CRhoParamArray::size() const
 {
     if ( m_array == null )
         return 0;
@@ -77,7 +90,7 @@ int CRhoParamArray::size()
     return m_array->size;
 }
 
-CRhoParams CRhoParamArray::getItem(int nIndex)
+CRhoParams CRhoParamArray::getItem(int nIndex) const
 {
     return m_array->value[nIndex];
 }

data/platform/shared/common/rhoparams.h

@@ -12,17 +12,19 @@ class CRhoParams
 protected:
     rho_param * m_pParams;
 
-    rho_param * findHashParam(const char* name);
+    const rho_param * findHashParam(const char* name) const;
 
 public:
     CRhoParams(rho_param *p);
-    CRhoParams(const CRhoParams& copy) : m_pParams(copy.m_pParams){} 
+    CRhoParams(const CRhoParams& copy) : m_pParams(copy.m_pParams){}
 
-    String getString(const char* name);
-    String getString(const char* szName, const char* szDefValue);
+    boolean has(const char* name) const;
 
-    void getHash(const char* name, Hashtable<String,String>& mapHeaders);
-    boolean getBool(const char* name);
+    String getString(const char* name) const;
+    String getString(const char* szName, const char* szDefValue) const;
+
+    void getHash(const char* name, Hashtable<String,String>& mapHeaders) const;
+    boolean getBool(const char* name) const;
 
     void free_params();
 };
@@ -32,9 +34,9 @@ class CRhoParamArray : public CRhoParams
     rho_array * m_array;
 public:
     CRhoParamArray(CRhoParams& oParams, const char* name);
-    int size();
+    int size() const;
 
-    CRhoParams getItem(int nIndex);
+    CRhoParams getItem(int nIndex) const;
 };
 
 } // namespace rho

data/platform/shared/db/DBAdapter.cpp

@@ -612,28 +612,6 @@ void CDBAdapter::setBulkSyncDB(String fDataName, String strCryptKey)
     copyTable("client_info", *this, db );
     copyChangedValues(db);
 
-    /*
-    //update User partition
-    if ( m_strDbPartition.compare(USER_PARTITION_NAME())==0 )
-    {
-        //copy all NOT user sources from current db to bulk db
-        startTransaction();
-        executeSQL("DELETE FROM sources WHERE partition=?", m_strDbPartition);
-        copyTable("sources", *this, db );
-        rollback();
-    }else
-    {
-        //remove all m_strDbPartition sources from user db
-        //copy all sources from bulk db to user db
-        CDBAdapter& dbUser  = getDB(USER_PARTITION_NAME());
-        dbUser.startTransaction();
-        dbUser.executeSQL("DELETE FROM sources WHERE partition=?", m_strDbPartition);
-
-        copyTable("sources", db, dbUser );
-
-        dbUser.endTransaction();
-    }*/
-
     getDBPartitions().put(m_strDbPartition.c_str(), &db);
     sync::CSyncThread::getSyncEngine().applyChangedValues(db);
     getDBPartitions().put(m_strDbPartition.c_str(), this);

data/platform/shared/json/RJSONTokener.c

@@ -169,16 +169,6 @@ void rjson_object_object_add(struct json_object* hash, const char *key,
 extern char* strndup(const char* str, size_t n);
 #endif
 
-void _release_values(struct json_tokener *tok)
-{
-  int n = 0;
-  for ( ; n < JSON_TOKENER_MAX_DEPTH; n++ )
-  {
-    if ( tok->stack[n].current )
-        rho_ruby_releaseValue((VALUE)tok->stack[n].current);
-  }
-}
-
 #define state  tok->stack[tok->depth].state
 #define saved_state  tok->stack[tok->depth].saved_state
 #define current tok->stack[tok->depth].current
@@ -189,7 +179,6 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
 {
   struct json_object *obj = NULL;
   char c;
-  int bRoot = 0;
 
   tok->char_offset = 0;
   tok->err = json_tokener_success;
@@ -226,20 +215,14 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
       case '{':
 	state = json_tokener_state_eatws;
 	saved_state = json_tokener_state_object_field_start;
-    bRoot = current == 0;
 	current = rjson_object_new_object();
-    if (bRoot)
-        rho_ruby_holdValue((VALUE)current);
-
+    rho_ruby_holdValue((VALUE)current);
 	break;
       case '[':
 	state = json_tokener_state_eatws;
 	saved_state = json_tokener_state_array;
-    bRoot = current == 0;
 	current = rjson_object_new_array();
-    if (bRoot)
-        rho_ruby_holdValue((VALUE)current);
-
+    rho_ruby_holdValue((VALUE)current);
 	break;
       case 'N':
       case 'n':
@@ -465,6 +448,7 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
       if(c == ']') {
 	saved_state = json_tokener_state_finish;
 	state = json_tokener_state_eatws;
+    rho_ruby_releaseValue((VALUE)current);
       } else {
 	if(tok->depth >= JSON_TOKENER_MAX_DEPTH-1) {
 	  tok->err = json_tokener_error_depth;
@@ -487,6 +471,7 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
       if(c == ']') {
 	saved_state = json_tokener_state_finish;
 	state = json_tokener_state_eatws;
+    rho_ruby_releaseValue((VALUE)current);
       } else if(c == ','||c == ';') {
 	saved_state = json_tokener_state_array;
 	state = json_tokener_state_eatws;
@@ -500,6 +485,7 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
       if(c == '}') {
 	saved_state = json_tokener_state_finish;
 	state = json_tokener_state_eatws;
+    rho_ruby_releaseValue((VALUE)current);
       } else if (c == '"' || c == '\'') {
 	tok->quote_char = c;
 	printbuf_reset(tok->pb);
@@ -559,6 +545,7 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
       if(c == '}') {
 	saved_state = json_tokener_state_finish;
 	state = json_tokener_state_eatws;
+    rho_ruby_releaseValue((VALUE)current);
       } else if(c == ','||c == ';') {
 	saved_state = json_tokener_state_object_field_start;
 	state = json_tokener_state_eatws;
@@ -579,9 +566,6 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
 
  out:
 
-  //if (root_item)
-  _release_values(tok);
-
   if(tok->err == json_tokener_success) 
       return rjson_object_get(current);
 
@@ -591,10 +575,18 @@ struct json_object* rjson_tokener_parse_ex(struct json_tokener *tok,
   return NULL;
 }
 
+VALUE rb_gc_enable(void);
+VALUE rb_gc_disable(void);
+
 VALUE rho_json_parse(VALUE v,VALUE str)
 {
     char* szError = 0;
-    VALUE res = rjson_tokener_parse(getStringFromValue(str), &szError);
+    VALUE res;
+
+    rb_gc_disable();
+    res = rjson_tokener_parse(getStringFromValue(str), &szError);
+    rb_gc_enable();
+
     if ( res != 0 )
         return res;
 

data/platform/shared/net/AsyncHttp.cpp

@@ -15,7 +15,7 @@ CAsyncHttp* CAsyncHttp::m_pInstance = 0;
 
 /*static*/ CAsyncHttp* CAsyncHttp::Create()
 {
-    if ( m_pInstance ) 
+    if ( m_pInstance )
         return m_pInstance;
 
     m_pInstance = new CAsyncHttp( );
@@ -67,7 +67,7 @@ void CAsyncHttp::cancelRequest(const char* szCallback)
         return;
     }
 
-    synchronized(getCommandLock());    
+    synchronized(getCommandLock());
     CHttpCommand* pCmd = (CHttpCommand*)getCurCommand();
 
     if ( pCmd != null && ( *szCallback == '*' || pCmd->m_strCallback.compare(szCallback) == 0) )
@@ -106,7 +106,8 @@ CAsyncHttp::CHttpCommand::CHttpCommand(String strCmd, rho_param *p) : m_params(p
 
     m_params.getHash("headers", m_mapHeaders);
 
-    m_NetRequest.setSslVerifyPeer(m_params.getBool("ssl_verify_peer"));
+    if(m_params.has("ssl_verify_peer"))
+        m_NetRequest.setSslVerifyPeer(m_params.getBool("ssl_verify_peer"));
 }
 
 void CAsyncHttp::CHttpCommand::execute()
@@ -115,11 +116,11 @@ void CAsyncHttp::CHttpCommand::execute()
     switch( m_eCmd )
     {
     case hcGet:
-        resp = getNet().doRequest( m_params.getString("http_command", "GET").c_str(), 
+        resp = getNet().doRequest( m_params.getString("http_command", "GET").c_str(),
             m_params.getString("url"), m_params.getString("body"), null, &m_mapHeaders);
         break;
     case hcPost:
-        resp = getNet().doRequest(m_params.getString("http_command", "POST").c_str(), 
+        resp = getNet().doRequest(m_params.getString("http_command", "POST").c_str(),
             m_params.getString("url"), m_params.getString("body"), null, &m_mapHeaders);
         break;
 
@@ -188,7 +189,7 @@ void CAsyncHttp::CHttpCommand::execute()
 unsigned long CAsyncHttp::CHttpCommand::getRetValue()
 {
     if ( m_strCallback.length() == 0 )
-        return rho_ruby_create_string(m_strResBody.c_str()); 
+        return rho_ruby_create_string(m_strResBody.c_str());
 
     return rho_ruby_get_NIL();
 }
@@ -256,7 +257,7 @@ CAsyncHttp::CAsyncHttpResponse::~CAsyncHttpResponse(){}
 
 extern "C" VALUE rjson_tokener_parse(const char *str, char** pszError );
 unsigned long CAsyncHttp::CAsyncHttpResponse::getObjectValue()
-{ 
+{
     if (m_NetResponse.isOK())
     {
         if ( m_strContentType.find("application/json") != String::npos )
@@ -272,7 +273,7 @@ unsigned long CAsyncHttp::CAsyncHttpResponse::getObjectValue()
         }
     }
 
-    return rho_ruby_create_string(m_NetResponse.getCharData()); 
+    return rho_ruby_create_string(m_NetResponse.getCharData());
 }
 
 } // namespace net

data/platform/shared/net/HttpServer.cpp

@@ -371,28 +371,53 @@ bool CHttpServer::run()
     for(;;) {
         RAWTRACE("Waiting for connections...");
         rho_ruby_start_threadidle();
-        //RAWTRACE("Before accept...");
-        SOCKET conn = accept(m_listener, NULL, NULL);
-        //RAWTRACE("After accept...");
+
+        fd_set readfds;
+        FD_ZERO(&readfds);
+        FD_SET(m_listener, &readfds);
+
+        timeval tv = {0};
+        unsigned long nTimeout = RHODESAPP().getTimer().getNextTimeout();
+        tv.tv_sec = nTimeout/1000;
+        tv.tv_usec = (nTimeout - tv.tv_sec*1000)*1000;
+        int ret = select(m_listener+1, &readfds, NULL, NULL, (tv.tv_sec == 0 && tv.tv_usec == 0 ? 0 : &tv) );
+
         rho_ruby_stop_threadidle();
-        if (!m_active) {
-            RAWTRACE("Stop HTTP server");
-            return true;
-        }
-        if (conn == INVALID_SOCKET) {
-#if !defined(OS_WINDOWS) && !defined(OS_WINCE)
-            if (RHO_NET_ERROR_CODE == EINTR)
-                continue;
-#endif
-            RAWLOG_ERROR1("Can not accept connection: %d", RHO_NET_ERROR_CODE);
-            return false;
-        }
+        bool bProcessed = false;
+        if (ret > 0) 
+        {
+            if (FD_ISSET(m_listener, &readfds))
+            {
+                //RAWTRACE("Before accept...");
+                SOCKET conn = accept(m_listener, NULL, NULL);
+                //RAWTRACE("After accept...");
+                if (!m_active) {
+                    RAWTRACE("Stop HTTP server");
+                    return true;
+                }
+                if (conn == INVALID_SOCKET) {
+        #if !defined(OS_WINDOWS) && !defined(OS_WINCE)
+                    if (RHO_NET_ERROR_CODE == EINTR)
+                        continue;
+        #endif
+                    RAWLOG_ERROR1("Can not accept connection: %d", RHO_NET_ERROR_CODE);
+                    return false;
+                }
 
-        RAWTRACE("Connection accepted, process it...");
-        bool bProcessed = process(conn);
+                RAWTRACE("Connection accepted, process it...");
+                bProcessed = process(conn);
 
-        RAWTRACE("Close connected socket");
-        closesocket(conn);
+                RAWTRACE("Close connected socket");
+                closesocket(conn);
+            }
+        }else if ( ret == 0 ) //timeout
+        {
+            bProcessed = RHODESAPP().getTimer().checkTimers();
+        }else
+        {
+            RAWLOG_ERROR1("select error: %d", ret);
+            return false;
+        }
 
         if ( bProcessed )
             rb_gc();
@@ -992,6 +1017,23 @@ bool CHttpServer::send_file(String const &path, HeaderList const &hdrs)
     return true;
 }
 
+bool CHttpServer::call_ruby_method(String const &uri, String const &body, String& strReply)
+{
+    Route route;
+    if (!dispatch(uri, route)) 
+        return false;
+
+    HeaderList headers;
+    headers.addElement(HttpHeader("Content-Type","application/x-www-form-urlencoded"));
+    VALUE req = create_request_hash(route.application, route.model, route.action, route.id,
+                                    "POST", uri, String(), headers, body);
+    VALUE data = callFramework(req);
+    strReply = String(getStringFromValue(data), getStringLenFromValue(data));
+    rho_ruby_releaseValue(data);
+
+    return true;
+}
+
 bool CHttpServer::decide(String const &method, String const &uri, String const &query,
                          HeaderList const &headers, String const &body)
 {