rhodes 3.2.3 → 3.3.0.beta.1

data/platform/shared/RhoConnectClient/RhoConnectClient.h

@@ -62,6 +62,17 @@ typedef struct _RHO_CONNECT_NOTIFY
     int error_code;
     char* error_message;
     char* callback_params;
+    unsigned long create_errors;
+
+    unsigned long update_errors_obj;
+    unsigned long update_errors_attrs;
+
+    unsigned long update_rollback_obj;
+    unsigned long update_rollback_attrs;
+
+    unsigned long delete_errors_obj;
+    unsigned long delete_errors_attrs;
+
 }RHO_CONNECT_NOTIFY;
 
 typedef struct _RHO_CONNECT_OBJECT_NOTIFY
@@ -83,6 +94,7 @@ void rho_connectclient_destroymodel(RHOM_MODEL* model);
 
 void rho_connectclient_init(RHOM_MODEL* pModels, int nModels);
 void rho_connectclient_destroy();
+void rho_connectclient_database_client_reset();
 void rho_connectclient_database_full_reset_and_logout();
 void rho_connectclient_database_fullclient_reset_and_logout();
 void rho_connectclient_database_full_reset(bool bClientReset);
@@ -94,8 +106,9 @@ void rho_connectclient_parse_objectnotify(const char* msg, RHO_CONNECT_OBJECT_NO
 void rho_connectclient_free_sync_objectnotify(RHO_CONNECT_OBJECT_NOTIFY* pNotify);
     
 unsigned long rho_connectclient_strarray_create();
-void rho_connectclient_strarray_add(unsigned long ar, const char* szStr);
+int rho_connectclient_strarray_add(unsigned long ar, const char* szStr);
 void rho_connectclient_strarray_delete(unsigned long ar);
+int rho_connectclient_strarray_find(unsigned long ar, const char* szStr);
 
 unsigned long rho_connectclient_strhasharray_create();
 void rho_connectclient_strhasharray_add(unsigned long ar, unsigned long hash);
@@ -109,6 +122,8 @@ unsigned long rho_connectclient_find_first(const char* szModel, unsigned long ha
 unsigned long rho_connectclient_find_all(const char* szModel, unsigned long hashCond );
 unsigned long rho_connectclient_findbysql(const char* szModel, const char* szSql, unsigned long arParams );
 
+int rho_connectclient_is_changed(const char* szModel);
+
 void rho_connectclient_save( const char* szModel, unsigned long hash );
 void rho_connectclient_itemdestroy( const char* szModel, unsigned long hash );
 
@@ -122,7 +137,11 @@ void rho_connectclient_hash_enumerate(unsigned long hash, int (*enum_func)(const
 
 void rho_connectclient_start_bulkupdate(const char* szModel);
 void rho_connectclient_stop_bulkupdate(const char* szModel);
-	
+
+void rho_connectclient_on_sync_create_error(const char* szModel, RHO_CONNECT_NOTIFY* oNotify, const char* szAction );
+void rho_connectclient_on_sync_update_error(const char* szModel, RHO_CONNECT_NOTIFY* oNotify, const char* szAction );
+void rho_connectclient_on_sync_delete_error(const char* szModel, RHO_CONNECT_NOTIFY* oNotify, const char* szAction );
+
 #ifdef __cplusplus
 };
 #endif //__cplusplus

data/platform/shared/common/Android.mk

@@ -29,7 +29,8 @@ LOCAL_SRC_FILES := \
     SplashScreen.cpp \
     ThreadQueue.cpp \
     Tokenizer.cpp \
-    RhoTime.cpp
+    RhoTime.cpp \
+    BundleManager.cpp
 LOCAL_C_INCLUDES := $(SHARED_PATH_INC)
     #$(SHARED_PATH_INC)/curl/include
 #    $(SHARED_PATH_INC)/ruby/include \

data/platform/shared/common/AutoPointer.h

@@ -26,6 +26,8 @@
 
 #pragma once
 
+#include "common/IRhoThreadImpl.h"
+
 namespace rho {
 namespace common {
 
@@ -162,5 +164,26 @@ private:
     CBaseDeleter* m_pDeleter;
 };
 
+template <typename FUNCTYPE, typename PARAMTYPE>
+class CStaticClassFunctor : public rho::common::IRhoRunnable
+{
+public:
+
+    CStaticClassFunctor( FUNCTYPE pFunc, PARAMTYPE param ): m_pFunc(pFunc), m_param(param){}
+    virtual void runObject()
+    { 
+        m_pFunc(m_param); 
+    }
+
+    ~CStaticClassFunctor()
+    {
+    }
+
+private:
+    FUNCTYPE m_pFunc;
+    PARAMTYPE m_param;
+
+};
+
 }
 }

data/platform/shared/common/BundleManager.cpp

@@ -0,0 +1,333 @@
+/*------------------------------------------------------------------------
+* (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
+*------------------------------------------------------------------------*/
+
+#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/Tokenizer.h"
+
+using namespace rho;
+using namespace rho::common;
+extern "C" void rho_sys_app_exit();
+extern "C" void rho_sys_impl_exit_with_errormessage(const char* szTitle, const char* szMsg);
+
+#if !defined(OS_WINDOWS) && !defined(OS_WINCE) && !defined(OS_MACOSX)
+void rho_sys_impl_exit_with_errormessage(const char* szTitle, const char* szMsg)
+{
+}
+#endif
+
+namespace rho {
+namespace common {
+
+class CFileTransaction
+{
+    unsigned int m_nError;
+    String m_strError;
+    String m_strFolder;
+public:
+    CFileTransaction(const String& strFolder);
+    ~CFileTransaction();
+    unsigned int start();
+    void commit();
+    unsigned int rollback();
+
+    boolean isError(){ return m_nError != 0; }
+    unsigned int getError(){ return m_nError; }
+    String getErrorText(){ return m_strError; }
+
+};
+
+class CReplaceBundleThread : public rho::common::CRhoThread
+{
+    DEFINE_LOGCLASS;
+
+    String m_bundle_path;
+
+    unsigned int removeFilesByList( const String& strListPath, const String& strSrcFolder );
+    unsigned int moveFilesByList( const String& strListPath, const String& strSrcFolder, const String& strDstFolder );
+    void doReplaceBundle();
+public:
+
+    CReplaceBundleThread(const char* root_path) 
+    {
+        m_bundle_path = root_path;
+        start(rho::common::IRhoRunnable::epNormal);
+    }
+    
+    virtual ~CReplaceBundleThread() {}
+    
+    virtual void run();
+
+    static void showError(int nError, const String& strError );
+};
+IMPLEMENT_LOGCLASS(CReplaceBundleThread,"RhoBundle");
+
+CFileTransaction::CFileTransaction(const String& strFolder) : m_strFolder(strFolder)
+{
+}
+
+unsigned int CFileTransaction::start()
+{
+    CRhoFile::createFolder((m_strFolder + "_temp_journal").c_str());
+
+    m_nError = CRhoFile::copyFoldersContentToAnotherFolder( CFilePath::join(m_strFolder, "").c_str(), (m_strFolder + "_temp_journal").c_str() );
+    if (m_nError)
+    {
+        m_strError = "Unable to copy folder: " + m_strFolder + " to : " + m_strFolder + "_temp_journal";
+        return m_nError;
+    }
+
+    m_nError = CRhoFile::renameFile( (m_strFolder + "_temp_journal").c_str(), (m_strFolder + "_journal").c_str());
+    if (m_nError)
+    {
+        m_strError = "Unable to rename folder: " + m_strFolder + "_temp_journal to : " + m_strFolder + "_journal";
+        return m_nError;
+    }
+
+    return m_nError;
+}
+
+CFileTransaction::~CFileTransaction()
+{
+    rollback();
+}
+
+void CFileTransaction::commit()
+{
+    String strFolder = m_strFolder;
+    
+    m_nError = CRhoFile::renameFile( (strFolder + "_journal").c_str(), (strFolder + "_temp_journal").c_str() );
+    if (m_nError)
+    {
+        m_strError = "Unable to rename folder: " + strFolder + "_journal to : " + strFolder + "_temp_journal";
+        return;
+    }
+    m_strFolder = "";
+
+    m_nError = CRhoFile::deleteFolder( (strFolder + "_temp_journal").c_str() );
+    if (m_nError)
+    {
+        m_strError = "Unable to delete folder: " + strFolder + "_temp_journal";
+        return;
+    }
+
+}
+
+unsigned int CFileTransaction::rollback()
+{
+    String strFolder = m_strFolder;
+    m_strFolder = "";
+
+    if ( strFolder.length() == 0 )
+        return 0;                                 
+
+    CRhoFile::deleteFolder( CFilePath(strFolder).changeBaseName("RhoBundle").c_str() );
+    CRhoFile::deleteFolder( (strFolder + "_temp_journal").c_str() );
+
+    if ( !CRhoFile::isFileExist((strFolder + "_journal").c_str()) )
+        return 0;
+
+    m_nError = CRhoFile::deleteFolder( (strFolder).c_str() );
+    if (m_nError)
+    {
+        m_strError = "Unable to delete folder: " + strFolder;
+        CReplaceBundleThread::showError(m_nError, m_strError);
+        return m_nError;
+    }
+
+    m_nError = CRhoFile::renameFile( (strFolder + "_journal").c_str(), (strFolder).c_str() );
+    if (m_nError)
+    {
+        m_strError = "Unable to rename folder: " + strFolder + "_journal" + " to : " + strFolder;
+        CReplaceBundleThread::showError(m_nError, m_strError);
+        return m_nError;
+    }
+
+    return m_nError;
+}
+
+unsigned int CReplaceBundleThread::removeFilesByList( const String& strListPath, const String& strSrcFolder )
+{
+    unsigned int nError = 0;
+    String strList;
+    CRhoFile::loadTextFile(strListPath.c_str(), strList);
+
+    CTokenizer oTokenizer( strList, "\n" );
+	while (oTokenizer.hasMoreTokens()) 
+    {
+		String strLine = oTokenizer.nextToken();
+
+        CTokenizer oLineTok( strLine, "\t" );
+        if ( !oLineTok.hasMoreTokens() )
+            continue;
+        String strPath = oLineTok.nextToken();
+        if ( !oLineTok.hasMoreTokens() )
+            continue;
+        String strType = oLineTok.nextToken();
+
+        if ( strType.compare("file") == 0)
+        {
+            nError = CRhoFile::deleteFile( CFilePath::join( strSrcFolder,strPath).c_str() );
+            if (nError != 0)
+            {
+                LOG(ERROR) + "Cannot remove file: " + CFilePath::join( strSrcFolder,strPath);
+                break;
+            }
+        }
+    }
+
+    return nError;
+}
+
+unsigned int CReplaceBundleThread::moveFilesByList( const String& strListPath, const String& strSrcFolder, const String& strDestFolder )
+{
+    unsigned int nError = 0;
+    String strList;
+    CRhoFile::loadTextFile(strListPath.c_str(), strList);
+
+    CTokenizer oTokenizer( strList, "\n" );
+	while (oTokenizer.hasMoreTokens()) 
+    {
+		String strLine = oTokenizer.nextToken();
+
+        CTokenizer oLineTok( strLine, "\t" );
+        if ( !oLineTok.hasMoreTokens() )
+            continue;
+        String strPath = oLineTok.nextToken();
+        if ( !oLineTok.hasMoreTokens() )
+            continue;
+        String strType = oLineTok.nextToken();
+        String strSrcPath = CFilePath::join( strSrcFolder,strPath);
+        String strDstPath = CFilePath::join( strDestFolder, strPath );
+
+        if ( strType.compare("dir") == 0)
+        {
+            CRhoFile::createFolder(strDstPath.c_str());
+        }else if ( strType.compare("file") == 0)
+        {
+            nError = CRhoFile::renameFile( strSrcPath.c_str(), strDstPath.c_str() );
+            if (nError != 0)
+            {
+                LOG(ERROR) + "Cannot rename file from : " + strSrcPath + "; to: " + strDstPath;
+                break;
+            }
+        }
+    }
+
+    return nError;
+}
+
+void CReplaceBundleThread::showError(int nError, const String& strError )
+{
+    LOG(ERROR) + "Error happen when replace bundle: " + strError + "; Code: " + LOGFMT("%d") + nError;
+
+    String strMsg = "Error happen when replace bundle: " + strError;
+
+    rho_sys_impl_exit_with_errormessage("Bundle update", strMsg.c_str());
+}
+
+void CReplaceBundleThread::run()
+{
+    //Stop application
+    rho_rhodesapp_callAppActiveCallback(0);
+    rho_rhodesapp_callUiDestroyedCallback();
+    RHODESAPP().stopApp();
+
+    doReplaceBundle();
+
+    rho_platform_restart_application();
+    rho_sys_app_exit();
+}
+
+void CReplaceBundleThread::doReplaceBundle()
+{
+    CFileTransaction oFT( RHODESAPP().getAppRootPath());
+    if (oFT.start())
+    {
+        showError(oFT.getError(), oFT.getErrorText());
+        return;
+    }
+
+    //Remove current files
+    unsigned int nError = removeFilesByList( CFilePath::join( RHODESAPP().getAppRootPath(), "rhofilelist.txt"), ::RHODESAPP().getAppRootPath() );
+    if ( nError != 0 )
+    {
+        showError(nError, "Remove files from bundle failed." );
+        return;
+    }
+
+    LOG(INFO) + "START";
+    //Copy new bundle
+    //nError = CRhoFile::moveFoldersContentToAnotherFolder( CFilePath::join(m_bundle_path, "RhoBundle/apps").c_str(), ::RHODESAPP().getAppRootPath().c_str() );
+    nError = moveFilesByList( CFilePath::join(m_bundle_path, "RhoBundle/apps/rhofilelist.txt").c_str(), CFilePath::join(m_bundle_path, "RhoBundle/apps"), ::RHODESAPP().getAppRootPath().c_str() );
+    if ( nError != 0 )
+    {
+        showError(nError, "Copy files to bundle failed." );
+        return;
+    }
+    LOG(INFO) + "STOP";
+    oFT.commit();
+
+    //Delete bundle folder
+    CRhoFile::deleteFolder( m_bundle_path.c_str());
+}
+
+}
+}
+
+extern "C" 
+{
+
+void rho_sys_replace_current_bundle(const char* path)
+{
+    new CReplaceBundleThread(path);    
+}
+
+int rho_sys_check_rollback_bundle(const char* szRhoPath)
+{
+    CFileTransaction oFT( CFilePath::join(szRhoPath, "apps") );
+    return oFT.rollback() != 0 ? 0 : 1;
+}
+
+int rho_sys_delete_folder(const char* szRhoPath)
+{
+    return CRhoFile::deleteFolder(szRhoPath);
+}
+
+} //extern "C"
+
+
+
+
+
+
+
+
+

data/platform/shared/common/RhoFile.cpp

@@ -29,9 +29,29 @@
 #include "common/Tokenizer.h"
 #include "common/RhoFilePath.h"
 
+#if defined(WINDOWS_PLATFORM)
+    extern "C" int _mkdir(const char * dir);
+    extern "C" int  _unlink(const char *path);
+#endif
+
+#if defined(OS_WINCE)
+    extern "C" int  _rename(const char *, const char *);
+#elif defined(OS_WINDOWS)
+    extern "C" int  rename(const char *, const char *);
+#endif
+
 namespace rho{
 namespace common{
 
+static wchar_t * translate_wchar(wchar_t *p, int from, int to)
+{
+    for (; *p; p++) {
+	    if (*p == from)
+	        *p = to;
+        }
+    return p;
+}
+
 class CFileInputStream : public InputStream
 {
     CRhoFile& m_oFile;
@@ -196,13 +216,11 @@ void CRhoFile::loadTextFile(const char* szFilePath, String& strFile)
         oFile.readString(strFile);
 }
 
-void CRhoFile::deleteFile( const char* szFilePath ){
+unsigned int CRhoFile::deleteFile( const char* szFilePath ){
 #if defined(OS_WINDOWS) || defined(OS_WINCE)
-    StringW wFileName;
-    common::convertToStringW(szFilePath,wFileName);
-    DeleteFileW(wFileName.c_str());
+    return (unsigned int)_unlink(szFilePath);
 #else
-    remove(szFilePath);
+    return (unsigned int)remove(szFilePath);
 #endif
 }
 
@@ -220,32 +238,27 @@ void CRhoFile::deleteFilesInFolder(const char* szFolderPath)
     if (hFind == INVALID_HANDLE_VALUE) 
         return;
 
-    while (FindNextFileW(hFind, &FindFileData) != 0) 
-    {
+    do{
         if ( FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY )
             continue;
 
         StringW wFileName = wFolderName + L"/" + FindFileData.cFileName;
         DeleteFileW(wFileName.c_str());
-    }
+    }while (FindNextFileW(hFind, &FindFileData) != 0); 
 
     FindClose(hFind);
 
 #else
-    delete_files_in_folder(szFolderPath);
+    rho_file_impl_delete_files_in_folder(szFolderPath);
 #endif
 }
 
-#if defined(WINDOWS_PLATFORM)
-    extern "C" int _mkdir(const char * dir);
-#endif
-
-/*static*/ void CRhoFile::createFolder(const char* szFolderPath)
+/*static*/ unsigned int CRhoFile::createFolder(const char* szFolderPath)
 {
 #if defined(WINDOWS_PLATFORM)
-    _mkdir(szFolderPath);
+    return _mkdir(szFolderPath);
 #else
-    mkdir(szFolderPath, S_IRWXU);
+    return mkdir(szFolderPath, S_IRWXU);
 #endif
 }
 
@@ -262,16 +275,13 @@ void CRhoFile::deleteFilesInFolder(const char* szFolderPath)
     }
 }
 
-/*static*/ void CRhoFile::renameFile( const char* szOldFilePath, const char* szNewFilePath )
+/*static*/ unsigned int CRhoFile::renameFile( const char* szOldFilePath, const char* szNewFilePath )
 {
-#if defined(OS_WINDOWS) || defined(OS_WINCE)
-    StringW wNewFileName, wOldFileName;
-    common::convertToStringW(szNewFilePath,wNewFileName);
-    common::convertToStringW(szOldFilePath,wOldFileName);
+#if defined(OS_WINCE)
+    return _rename( szOldFilePath, szNewFilePath );
 
-	BOOL res = MoveFileW( wOldFileName.c_str(), wNewFileName.c_str());
 #else
-    rename( szOldFilePath, szNewFilePath );
+    return rename( szOldFilePath, szNewFilePath );
 #endif
 
 }
@@ -295,6 +305,179 @@ void CRhoFile::deleteFilesInFolder(const char* szFolderPath)
         oFile.close();
     }
 }
+    
+/*static*/ unsigned int CRhoFile::copyFile(const char* szSrcFile, const char* szDstFile) {
+    
+    CRhoFile src;
+    CRhoFile dst;
+    
+    if (!src.open(szSrcFile, OpenReadOnly)) {
+        return -1;
+    }
+    if (!dst.open(szDstFile, OpenForWrite)) {
+        return -1;
+    }
+    
+    int buf_size = 1 << 16;
+    unsigned char* buf = new unsigned char[buf_size];
+    
+    unsigned int to_copy = src.size();
+    
+    while (to_copy > 0) {
+        int portion_size = buf_size;
+        if (to_copy < portion_size) {
+            portion_size = to_copy;
+        }
+        src.readData(buf, 0, portion_size);
+        dst.write(buf, portion_size);
+        
+        to_copy -= portion_size;
+    }
+    
+    src.close();
+    dst.flush();
+    dst.close();
+    
+    delete buf;
 
+    return 0;
 }
+    
+/*static*/ unsigned int CRhoFile::deleteFolder(const char* szFolderPath) 
+{
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+
+	StringW  swPath;
+    convertToStringW(szFolderPath, swPath);
+	wchar_t* name = new wchar_t[ swPath.length() + 2];
+    swprintf(name, L"%s%c", swPath.c_str(), '\0');
+    translate_wchar(name, L'/', L'\\');
+
+    SHFILEOPSTRUCTW fop = {0};
+
+	fop.hwnd = NULL;
+	fop.wFunc = FO_DELETE;		
+        fop.pFrom = name;
+	fop.pTo = NULL;
+	fop.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOCONFIRMMKDIR 
+#if defined(OS_WINDOWS) || defined(OS_PLATFORM_MOTCE)
+                 | FOF_NOERRORUI
+#endif        
+        ;
+        int result = SHFileOperationW(&fop);
+
+    delete name;
+
+    return result == 0 ? 0 : (unsigned int)-1;
+#else
+    rho_file_impl_delete_folder(szFolderPath);
+    return 0;
+#endif
+
 }
+
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+static unsigned int copyFolder(const StringW& strSrc, const StringW& strDst, boolean bMove)
+{
+    unsigned int nErr = 0;
+
+    CRhoFile::createFolder(convertToStringA(strDst).c_str());
+
+    StringW wFolderMask = CFilePath::join(strSrc, L"*");
+
+    WIN32_FIND_DATAW FindFileData = {0};
+    HANDLE hFind = INVALID_HANDLE_VALUE;
+
+    hFind = FindFirstFileW(wFolderMask.c_str(), &FindFileData);
+    if (hFind == INVALID_HANDLE_VALUE) 
+        return GetLastError();
+
+    do{
+        if (!wcscmp(FindFileData.cFileName , L".")) continue ;
+		if (!wcscmp(FindFileData.cFileName , L"..")) continue ;
+
+        if ( FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY )
+        {
+            int i = 0;
+            nErr = copyFolder( CFilePath::join(strSrc,FindFileData.cFileName), CFilePath::join(strDst,FindFileData.cFileName), bMove );
+        }
+        else
+        {
+            if ( bMove )
+            {
+                CRhoFile::deleteFile(convertToStringA(CFilePath::join(strDst,FindFileData.cFileName)).c_str());
+                nErr = CRhoFile::renameFile(convertToStringA(CFilePath::join(strSrc,FindFileData.cFileName)).c_str(), convertToStringA(CFilePath::join(strDst,FindFileData.cFileName)).c_str());
+            }
+            else
+                nErr = CRhoFile::copyFile( convertToStringA(CFilePath::join(strSrc,FindFileData.cFileName)).c_str(), convertToStringA(CFilePath::join(strDst,FindFileData.cFileName)).c_str() );
+        }
+
+        if ( nErr != 0 )
+            return nErr;
+    }while (FindNextFileW(hFind, &FindFileData) != 0); 
+
+    FindClose(hFind);
+
+    return 0;
+}
+#endif
+
+/*static*/ unsigned int CRhoFile::copyFoldersContentToAnotherFolder(const char* szSrcFolderPath, const char* szDstFolderPath) 
+{
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+
+    StringW strSrcW, strDstW;
+    common::convertToStringW(szSrcFolderPath,strSrcW);
+    common::convertToStringW(szDstFolderPath,strDstW);
+    String_replace(strSrcW, L'/', L'\\' );
+    String_replace(strDstW, L'/', L'\\' );
+
+    return copyFolder(strSrcW, strDstW, false);
+#else
+    rho_file_impl_copy_folders_content_to_another_folder(szSrcFolderPath, szDstFolderPath);
+    return 0;
+#endif
+}
+
+/*static*/ unsigned int CRhoFile::moveFoldersContentToAnotherFolder(const char* szSrcFolderPath, const char* szDstFolderPath) 
+{
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+
+    StringW strSrcW, strDstW;
+    common::convertToStringW(szSrcFolderPath,strSrcW);
+    common::convertToStringW(szDstFolderPath,strDstW);
+    String_replace(strSrcW, L'/', L'\\' );
+    String_replace(strDstW, L'/', L'\\' );
+
+    return copyFolder(strSrcW, strDstW, true);
+
+#else
+    rho_file_impl_move_folders_content_to_another_folder(szSrcFolderPath, szDstFolderPath);
+    return 0;
+#endif
+}
+
+}
+}
+
+#if defined(OS_MACOSX) || defined(OS_ANDROID)
+    void rho_file_impl_move_folders_content_to_another_folder(const char* szSrcFolderPath, const char* szDstFolderPath) {
+        
+    }
+#else
+extern "C" {
+    
+    void rho_file_impl_delete_folder(const char* szFolderPath) {
+        
+    }
+    
+    void rho_file_impl_copy_folders_content_to_another_folder(const char* szSrcFolderPath, const char* szDstFolderPath) {
+        
+    }
+    
+    void rho_file_impl_move_folders_content_to_another_folder(const char* szSrcFolderPath, const char* szDstFolderPath) {
+        
+    }
+    
+}
+#endif