rhodes 3.2.3 → 3.3.0.beta.1

data/platform/shared/common/RhoFile.h

@@ -63,14 +63,20 @@ public:
 
     static unsigned int getFileSize( const char* szFilePath );
     static bool         isFileExist( const char* szFilePath );
-    static void         deleteFile( const char* szFilePath );
-    static void         renameFile( const char* szOldFilePath, const char* szNewFilePath );
+    static unsigned int deleteFile( const char* szFilePath );
+    static unsigned int renameFile( const char* szOldFilePath, const char* szNewFilePath );
     static void         deleteFilesInFolder(const char* szFolderPath);
     static void         loadTextFile(const char* szFilePath, String& strFile);
-    static void         createFolder(const char* szDirPath);
+    static unsigned int createFolder(const char* szDirPath);
     static void         recursiveCreateDir(const char* szFolderPath, const char* szBasePath);
     static void         readStringFromFile( const char* szFilePath, String& strData );
     static void         writeStringToFile( const char* szFilePath, String& strData );
+    
+    static unsigned int copyFile(const char* szSrcFile, const char* szDstFile);
+    static unsigned int deleteFolder(const char* szFolderPath);
+    static unsigned int copyFoldersContentToAnotherFolder(const char* szSrcFolderPath, const char* szDstFolderPath);
+    static unsigned int moveFoldersContentToAnotherFolder(const char* szSrcFolderPath, const char* szDstFolderPath);
+
 private:
     CRhoFile(const CRhoFile&);
     void operator=(const CRhoFile&);
@@ -80,6 +86,10 @@ private:
 }
 }
 
-extern "C" void delete_files_in_folder(const char *szFolderPath);
+extern "C" void rho_file_impl_delete_files_in_folder(const char *szFolderPath);
+
+extern "C" void rho_file_impl_delete_folder(const char* szFolderPath);
+extern "C" void rho_file_impl_copy_folders_content_to_another_folder(const char* szSrcFolderPath, const char* szDstFolderPath);
+extern "C" void rho_file_impl_move_folders_content_to_another_folder(const char* szSrcFolderPath, const char* szDstFolderPath);
 
 #endif //_RHOFILE_H_

data/platform/shared/common/RhoFilePath.h

@@ -98,6 +98,24 @@ public:
 
         return res;
     }
+#if defined(WINDOWS_PLATFORM)
+    static StringW join(const StringW& path1, const StringW& path2)
+    {
+        boolean bSlash1 = path1.length()>0 && (path1[path1.length()-1] == L'/' || path1[path1.length()-1] == L'\\');
+        boolean bSlash2 = path2.length()>0 && (path2[0] == L'/' || path2[0] == L'\\');
+        StringW res;
+        if (bSlash1 && bSlash2)
+            res = path1 + path2.substr(1);
+        else if ( bSlash1 || bSlash2 )
+            res = path1 + path2;
+        else
+        {
+            res = path1 + L"/" + path2;
+        }
+
+        return res;
+    }
+#endif
 
     static String normalizePath(const String& path1)
     {

data/platform/shared/common/RhoStd.h

@@ -100,6 +100,16 @@ inline boolean String_startsWith(const String& str, const String& strPrefix)
     return strncmp(str.c_str(), strPrefix.c_str(), strPrefix.length()) == 0;
 }
 
+template<typename StrType>
+inline void String_replace(StrType& str, int from, int to)
+{
+    for( int i = 0; i < str.length(); i++)
+    {
+        if ( str[i] == from )
+            str[i] = to;
+    }
+}
+
 template<class Type>
 class Vector : public std::vector<Type>{
 public:
@@ -260,7 +270,7 @@ public:
 
     boolean containsKey(const TKEY& key)
     {
-        return std::map<TKEY,TVALUE>::find(key) != std::map<TKEY,TVALUE>::end();
+        return !std::map<TKEY,TVALUE>::empty() && std::map<TKEY,TVALUE>::find(key) != std::map<TKEY,TVALUE>::end();
     }
 };
 

data/platform/shared/common/RhoThread.h

@@ -29,6 +29,7 @@
 #include "RhoStd.h"
 #include "IRhoThreadImpl.h"
 #include "AutoPointer.h"
+#include "common/RhoSystem.h"
 
 namespace rho {
 namespace common {
@@ -42,6 +43,7 @@ class CRhoThread : public IRhoRunnable
     static const int TS_RUNNING = 4;
 
     int m_nState;
+    unsigned int m_nThreadID;
 public:
 
     CRhoThread();
@@ -55,6 +57,7 @@ public:
     virtual void run() = 0;
     virtual void runObject()
     {
+        m_nThreadID = CSystem::getThreadID();
         run();
         m_nState = TS_NONE;
     }
@@ -62,7 +65,7 @@ public:
     boolean isStopping(){return (m_nState&TS_STOPPING) != 0;}
     boolean isWaiting(){return (m_nState&TS_WAIT) != 0;}
     boolean isAlive(){return (m_nState&TS_RUNNING) != 0;}
-
+    unsigned int getThreadID(){ return m_nThreadID; }
 };
 
 }

data/platform/shared/common/RhodesApp.cpp

@@ -27,6 +27,7 @@
 #include "RhodesApp.h"
 #include "common/RhoMutexLock.h"
 #include "common/IRhoClassFactory.h"
+#include "common/RhoFile.h"
 #include "common/RhoConf.h"
 #include "common/RhoFilePath.h"
 #include "common/RhoAppAdapter.h"
@@ -41,6 +42,7 @@
 #include "rubyext/WebView.h"
 #include "rubyext/GeoLocation.h"
 #include "common/app_build_configs.h"
+#include "unzip/unzip.h"
 
 #include <algorithm>
 
@@ -59,7 +61,7 @@ void rho_db_init_attr_manager();
 void rho_sys_app_exit();
 void rho_sys_report_app_started();
 }
-
+    
 namespace rho {
 namespace common{
 
@@ -277,6 +279,9 @@ void CAppCallbacksQueue::processCommand(IQueueCommand* pCmd)
         delete m_pInstance;
 
     m_pInstance = 0;
+    
+    
+
 }
 
 CRhodesApp::CRhodesApp(const String& strRootPath)
@@ -314,7 +319,7 @@ void CRhodesApp::run()
     RhoRubyStart();
     rubyext::CGeoLocation::Create();
 
-    rho_db_init_attr_manager();
+    //rho_db_init_attr_manager();
 
     LOG(INFO) + "Starting sync engine...";
     sync::CSyncThread::Create();
@@ -496,6 +501,9 @@ void CRhodesApp::callUiCreatedCallback()
 
 void CRhodesApp::callUiDestroyedCallback()
 {
+    if ( m_bExit )
+        return;
+
     String strUrl = m_strHomeUrl + "/system/uidestroyed";
     NetResponse resp = getNetRequest().pullData( strUrl, null );
     if ( !resp.isOK() )
@@ -571,7 +579,9 @@ void CRhodesApp::callBarcodeCallback(String strCallbackUrl, const String& strBar
         strBody += "&status=fail";
     }
 
-    getNetRequest().pushData( strCallbackUrl, strBody, null );
+    strBody += "&rho_callback=1";
+    //getNetRequest().pushData( strCallbackUrl, strBody, null );
+    runCallbackInThread(strCallbackUrl, strBody);
 }
 
 void CRhodesApp::callCameraCallback(String strCallbackUrl, const String& strImagePath, 
@@ -607,7 +617,8 @@ void CRhodesApp::callSignatureCallback(String strCallbackUrl, const String& strS
 			strBody = "status=ok&signature_uri=db%2Fdb-files%2F" + strSignaturePath;
 		
 		strBody += "&rho_callback=1";
-		getNetRequest().pushData( strCallbackUrl, strBody, null );
+		//getNetRequest().pushData( strCallbackUrl, strBody, null );
+        runCallbackInThread(strCallbackUrl, strBody);
 	}
 	
 void CRhodesApp::callDateTimeCallback(String strCallbackUrl, long lDateTime, const char* szData, int bCancel )
@@ -961,11 +972,14 @@ String CRhodesApp::getAppName()
     String strAppName;
 #ifdef OS_WINCE
     String path = rho_native_rhopath();
-    int last, pre_last;
+    String_replace(path, '/', '\\');
+
+    int nEnd = path.find_last_of('\\');
+    nEnd = path.find_last_of('\\', nEnd-1)-1;
+
+    int nStart = path.find_last_of('\\', nEnd) +1;
+    strAppName = path.substr( nStart, nEnd-nStart+1);
 
-    last = path.find_last_of('\\');
-    pre_last = path.substr(0, last).find_last_of('\\');
-    strAppName = path.substr(pre_last + 1, last - pre_last - 1);
 #else
     strAppName = "Rhodes";
 #endif
@@ -1597,3 +1611,12 @@ int rho_rhodesapp_canstartapp(const char* szCmdLine, const char* szSeparators)
 }
 
 } //extern "C"
+
+
+
+
+
+
+
+
+

data/platform/shared/common/RhodesApp.h

@@ -166,6 +166,16 @@ protected:
     void initAppUrls();
 };
 
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+extern "C" void rho_wm_impl_performOnUiThread(rho::common::IRhoRunnable* pTask);
+
+template <typename FUNCTYPE, typename PARAMTYPE>
+void rho_callInUIThread( FUNCTYPE pFunc, PARAMTYPE param )
+{
+    rho_wm_impl_performOnUiThread( new rho::common::CStaticClassFunctor<FUNCTYPE,PARAMTYPE>(pFunc, param) );
+}
+#endif //defined(OS_WINDOWS) || defined(OS_WINCE)
+
 }
 }
 
@@ -234,6 +244,10 @@ int rho_rhodesapp_check_mode();
 
 int rho_rhodesapp_canstartapp(const char* szCmdLine, const char* szSeparators);
 
+    
+// should be implemented in platforms code
+void rho_platform_restart_application();    
+    
 #ifdef __cplusplus
 };
 #endif //__cplusplus

data/platform/shared/common/RhodesAppBase.cpp

@@ -127,23 +127,23 @@ boolean CRhodesAppBase::isBaseUrl(const String& strUrl)
 
 extern "C" {
 
-int rho_unzip_file(const char* szZipPath)
+int rho_sys_unzip_file(const char* szZipPath, const char* psw)
 {
     rho::common::CFilePath oPath(szZipPath);
     rho::String strBaseDir = oPath.getFolderName();
 #if defined(UNICODE) && defined(WIN32)
     rho::StringW strZipPathW;
     rho::common::convertToStringW(szZipPath, strZipPathW);
-    HZIP hz = OpenZipFile(strZipPathW.c_str(), "");
+    HZIP hz = OpenZipFile(strZipPathW.c_str(), psw);
     if ( !hz )
-        return 0;
+        return -1;
 
 	// Set base for unziping
     SetUnzipBaseDir(hz, rho::common::convertToStringW(strBaseDir).c_str());
 #else
-    HZIP hz = OpenZipFile(szZipPath, "");
+    HZIP hz = OpenZipFile(szZipPath, psw);
     if ( !hz )
-        return 0;
+        return -1;
 
 	// Set base for unziping
     SetUnzipBaseDir(hz,strBaseDir.c_str() );
@@ -167,7 +167,7 @@ int rho_unzip_file(const char* szZipPath)
 
 	CloseZip(hz);
 
-    return res == ZR_OK ? 1 : 0;
+    return res;
 }
 
 #ifdef RHODES_EMULATOR

data/platform/shared/common/RhodesAppBase.h

@@ -91,7 +91,7 @@ const char* rho_rhodesapp_getplatform();
 //const char* rho_rhodesapp_getrhodespath();
 void rho_file_recursive_createdir(const char* szPath, const char* szBasePath);
 
-int rho_unzip_file(const char* szZipPath);
+int rho_unzip_file(const char* szZipPath, const char* psw);
 
 void rho_free_callbackdata(void* pData);
 	

data/platform/shared/common/emml.h

@@ -0,0 +1,34 @@
+#include "ruby/ext/rho/rhoruby.h"
+#include <AtlBase.h>
+#include <AtlConv.h>
+
+using namespace std;
+
+namespace rho 
+{
+	namespace emml 
+	{
+		wstring rubyValueToEMML(rho_param* p)
+		{
+			wstring emml;
+
+			if (p && p->type == RHO_PARAM_HASH) {
+				for (int i = 0; i < p->v.hash->size; i++) {
+					emml.append(CA2W(p->v.hash->name[i]));
+					emml.append(L":");
+					emml.append(CA2W(p->v.hash->value[i]->v.string));
+					if(i < p->v.hash->size - 1)
+						emml.append(L";");
+				}
+			}
+			rho_param_free(p);
+			return emml;
+		}
+
+		void addEMML(wstring& dest, wchar_t* src)
+		{
+			dest.append(L";");
+			dest.append(src);		
+		}
+	}
+}

data/platform/shared/common/iphone/RhoFileImpl.m

@@ -31,7 +31,7 @@
 
 #define ZIP_STD 1
 
-extern void delete_files_in_folder(const char *szFolderPath);
+extern void rho_file_impl_delete_files_in_folder(const char *szFolderPath);
 
 @interface RhoFileImpl : NSObject {
 }
@@ -59,7 +59,35 @@ extern void delete_files_in_folder(const char *szFolderPath);
 
 @end
 
-void delete_files_in_folder(const char *szFolderPath)
+void rho_file_impl_delete_files_in_folder(const char *szFolderPath)
 {
 	[RhoFileImpl deleteFilesInFolder:[NSString stringWithUTF8String:szFolderPath]];
 }
+
+void rho_file_impl_delete_folder(const char* szFolderPath) {
+	NSFileManager *fileManager = [NSFileManager defaultManager];
+	NSError *err;
+    [fileManager removeItemAtPath:[NSString stringWithUTF8String:szFolderPath] error:&err];
+}
+
+void rho_file_impl_copy_folders_content_to_another_folder(const char* szSrcFolderPath, const char* szDstFolderPath) {
+
+	NSFileManager *fileManager = [NSFileManager defaultManager];
+    
+    NSString* src_folder = [NSString stringWithUTF8String:szSrcFolderPath];
+    NSString* dst_folder = [NSString stringWithUTF8String:szDstFolderPath];
+	
+	NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:src_folder];
+	if (enumerator == nil)
+		return;
+	
+	NSError *err;
+	id path;
+	while ((path = [enumerator nextObject])) {
+		NSString *src_item = [NSString stringWithFormat:@"%@/%@", src_folder, [NSString stringWithFormat:@"%@", path]];
+		NSString *dst_item = [NSString stringWithFormat:@"%@/%@", dst_folder, [NSString stringWithFormat:@"%@", path]];
+		[fileManager copyItemAtPath:src_item toPath:dst_item error:&err];
+	}
+    
+}
+

data/platform/shared/common/map/BaseMapEngine.cpp

@@ -608,7 +608,7 @@ public:
 
     void onError(String const &) {}
 
-    void onSuccess(double latitude, double longitude)
+    void onSuccess(double latitude, double longitude, const char* adress)
     {
         RHO_MAP_TRACE2("CenterResolved: latitude=%lf, longitude=%lf", latitude, longitude);
         m_mapview->moveTo(latitude, longitude);
@@ -627,10 +627,10 @@ public:
 
     void onError(String const &) {}
 
-    void onSuccess(double latitude, double longitude)
+    void onSuccess(double latitude, double longitude, const char* adress)
     {
         RHO_MAP_TRACE2("AnnotationResolved: latitude=%lf, longitude=%lf", latitude, longitude);
-        Annotation ann(m_ann.title(), m_ann.subtitle(), latitude, longitude, m_ann.url());
+        Annotation ann(m_ann.title(), m_ann.subtitle(), latitude, longitude, m_ann.url(), m_ann.pass_location());
         m_mapview->addAnnotation(ann);
     }
 

data/platform/shared/common/map/GeocodingMapEngine.cpp

@@ -36,6 +36,8 @@
 #include "common/RhoFile.h"
 #include "net/INetRequest.h"
 
+#include "ruby/ext/rho/rhoruby.h"
+
 
 #undef DEFAULT_LOGCATEGORY
 #define DEFAULT_LOGCATEGORY "GeocodingMapEngine"
@@ -53,7 +55,8 @@ String GoogleGeoCoding::Command::toString()
 {
     return address;
 }
-
+    
+    
 IMPLEMENT_LOGCLASS(GoogleGeoCoding,"GGeoCoding");
 GoogleGeoCoding::GoogleGeoCoding()
 {
@@ -96,8 +99,12 @@ void GoogleGeoCoding::resolve(String const &address, GeoCodingCallback *cb)
     RHO_MAP_TRACE1("GoogleGeoCoding: resolve address=%s", address.c_str());
     addQueueCommand(new Command(address, cb));
 }
+    
+void GoogleGeoCoding::resolve(float latitude, float longitude, GeoCodingCallback *cb) {
+    addQueueCommand(new Command(latitude, longitude, cb));
+}
 
-static bool parse_json(const char *data, double *plat, double *plon)
+static bool parse_json(const char *data, double *plat, double *plon, String* adress, bool* coord_ok, bool* adress_ok)
 {
     RHO_MAP_TRACE1("parse_json: data=%s", data);
     json::CJSONEntry json(data);
@@ -105,17 +112,43 @@ static bool parse_json(const char *data, double *plat, double *plon)
     RHO_MAP_TRACE1("parse_json: status=%s", status);
     if (strcasecmp(status, "OK") != 0)
         return false;
+    bool params_founded = false;
+    if (adress_ok != NULL) {
+        *adress_ok = false;
+    }
+    if (coord_ok != NULL) {
+        *coord_ok = false;
+    }
     for (json::CJSONArrayIterator results = json.getEntry("results"); !results.isEnd(); results.next())
     {
         json::CJSONEntry item = results.getCurItem();
-        if (!item.hasName("geometry"))
-            continue;
-
-        json::CJSONEntry geometry = item.getEntry("geometry");
-        json::CJSONEntry location = geometry.getEntry("location");
-        *plat = location.getDouble("lat");
-        *plon = location.getDouble("lng");
-        return true;
+        
+        
+        if (item.hasName("formatted_address")) {
+            json::CJSONEntry formatted_address = item.getEntry("formatted_address");
+            if (adress != NULL) {
+                *adress = formatted_address.getString();
+            }
+            params_founded = true;
+            if (adress_ok != NULL) {
+                *adress_ok = true;
+            }
+        }
+        
+        if (item.hasName("geometry")) {
+            json::CJSONEntry geometry = item.getEntry("geometry");
+            json::CJSONEntry location = geometry.getEntry("location");
+            *plat = location.getDouble("lat");
+            *plon = location.getDouble("lng");
+            params_founded = true;
+            if (coord_ok != NULL) {
+                *coord_ok = true;
+            }
+        }
+        
+        if (params_founded) {
+            return true;
+        }
     }
 
     return false;
@@ -126,8 +159,19 @@ void GoogleGeoCoding::processCommand(IQueueCommand *pCmd)
     Command *cmd = (Command*)pCmd;
     GeoCodingCallback &cb = *(cmd->callback);
 
-    String url = "http://maps.googleapis.com/maps/api/geocode/json?address=";
-    url += net::URI::urlEncode(cmd->address);
+    String url = "http://maps.googleapis.com/maps/api/geocode/json?";
+    
+    if (cmd->is_inverse) {
+        char* buf = new char[2048];
+        url += "latlng=";
+        sprintf(buf, "%f,%f", (float)cmd->latitude, (float)cmd->longitude);
+        url += buf;
+        delete buf;
+    }
+    else {
+        url += "address=";
+        url += net::URI::urlEncode(cmd->address);
+    }
     url += "&sensor=false";
 
     RHO_MAP_TRACE1("GoogleGeoCoding: processCommand: url=%s", url.c_str());
@@ -143,10 +187,28 @@ void GoogleGeoCoding::processCommand(IQueueCommand *pCmd)
     RHO_MAP_TRACE("GoogleGeoCoding: processCommand: Parse received json...");
 
     double latitude, longitude;
-    if (parse_json((const char *)data, &latitude, &longitude))
+    String cadress;
+    bool adress_ok = false;
+    bool coordinates_ok = false;
+    
+    if (parse_json((const char *)data, &latitude, &longitude, &cadress, &coordinates_ok, &adress_ok))
     {
         RHO_MAP_TRACE("GoogleGeoCoding: processCommand: json parsed successfully");
-        cb.onSuccess(latitude, longitude);
+        if (cmd->is_inverse && adress_ok) {
+            cb.onSuccess(latitude, longitude, cadress.c_str());
+        }
+        else if (coordinates_ok) {
+            if (adress_ok) {
+                cb.onSuccess(latitude, longitude, cadress.c_str());
+            }
+            else {
+                cb.onSuccess(latitude, longitude, NULL);
+            }
+        }
+        else {
+            RHO_MAP_TRACE("GoogleGeoCoding: processCommand: can't found response in json");
+            cb.onError("Can not found response in JSON");
+        }
     }
     else
     {
@@ -198,3 +260,132 @@ void GoogleGeoCoding::processCommand(IQueueCommand *pCmd)
 } // namespace common
 } // namespace rho
 
+
+static rho::common::map::GoogleGeoCoding* ourGeocode = NULL;
+
+static rho::common::map::GoogleGeoCoding* getGeocodeSignletone() {
+    if (ourGeocode == NULL) {
+        ourGeocode = new rho::common::map::GoogleGeoCoding();
+    }
+    return ourGeocode;
+}
+
+class RhoGoogleGeocodeCallbackImpl : public rho::common::map::GeoCodingCallback {
+public:
+    RhoGoogleGeocodeCallbackImpl(rho::String adress, rho::String callback, int tag) {
+        mAdress = adress;
+        mCallback = callback;
+        mTag = tag;
+    }
+    
+    virtual ~RhoGoogleGeocodeCallbackImpl() {
+        
+    }
+    
+    virtual void onError(rho::String const &description) {
+        char* buf = new char[2048];
+        
+        if (buf == NULL) {
+            RAWLOG_ERROR("can not allocate temporary char buffer in GeoLocation callback");
+            return;
+        }
+        
+        sprintf(buf,"&rho_callback=1&status=error&description=%s", description.c_str()); 
+        
+        char* norm_url = rho_http_normalizeurl(mCallback.c_str());
+        rho_net_request_with_data(norm_url, buf);
+        rho_http_free(norm_url);
+        
+        delete buf;
+        //delete this;
+    }
+
+    virtual void onSuccess(double latitude, double longitude, const char* adress) {
+        char* buf = new char[2048];
+        
+        if (buf == NULL) {
+            RAWLOG_ERROR("can not allocate temporary char buffer in GeoLocation callback");
+            return;
+        }
+        
+        if (adress != NULL) {
+            rho::String coded_adr = adress;
+            coded_adr = rho::net::URI::urlEncode(coded_adr);
+            sprintf(buf,"&rho_callback=1&status=ok&tag=%d&latitude=%f&longitude=%f&adress=%s", mTag, (float)latitude, (float)longitude, coded_adr.c_str()); 
+        }
+        else {
+            sprintf(buf,"&rho_callback=1&status=ok&tag=%d&latitude=%f&longitude=%f", mTag, (float)latitude, (float)longitude); 
+        }
+        
+            
+        char* norm_url = rho_http_normalizeurl(mCallback.c_str());
+        rho_net_request_with_data(norm_url, buf);
+        rho_http_free(norm_url);
+                
+        delete buf;
+        //delete this;
+    }
+    
+    
+private:
+    rho::String mAdress;
+    rho::String mCallback;
+    int mTag;
+};
+
+
+void rho_geoimpl_do_geocoding(rho_param* p, const char* callback, int callback_tag) {
+    
+    const char* c_adress = NULL;
+    bool adress_setted = false;
+    
+    float longitude = 0;
+    float latitude = 0;
+    bool longitude_setted = false;
+    bool latitude_setted = false;
+    
+    switch (p->type) {
+        case RHO_PARAM_HASH: {
+            for (int i = 0, lim = p->v.hash->size; i < lim; ++i) {
+                const char *name = p->v.hash->name[i];
+                rho_param *value = p->v.hash->value[i];
+                
+                if (strcasecmp(name, "adress") == 0) {
+					c_adress = value->v.string;
+                    adress_setted = true;
+                }
+                if (strcasecmp(name, "latitude") == 0) {
+                    latitude = strtod(value->v.string, NULL);
+                    latitude_setted = true;
+                }
+                if (strcasecmp(name, "longitude") == 0) {
+                    longitude_setted = true;
+                    longitude = strtod(value->v.string, NULL);
+                }
+            }
+        }
+        break;
+        default: {
+            RAWLOG_ERROR("Unexpected parameter type for do_geocoding, should be Hash");
+            return;
+        }
+    }
+    if ((c_adress == NULL) && (!latitude_setted && !longitude_setted)) {
+        RAWLOG_ERROR("Unexpected parameter type for do_geocoding, should be Hash with 'adress' or 'latitude' + 'longitude' parameters");
+        return;
+    }
+    
+    if (adress_setted) {
+        rho::String adress = c_adress;
+    
+        getGeocodeSignletone()->resolve(adress, new RhoGoogleGeocodeCallbackImpl(adress, callback, callback_tag));\
+    }
+    else if (latitude_setted && longitude_setted) {
+        getGeocodeSignletone()->resolve(latitude, longitude, new RhoGoogleGeocodeCallbackImpl("", callback, callback_tag));
+    }
+    else {
+        RAWLOG_ERROR("Ivalid parameters type for do_geocoding, should be Hash with 'adress' or 'latitude' + 'longitude' parameters");
+    }
+}
+
+