1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-22 22:13:35 +02:00
vcmi/lib/VCMIDirs.cpp
Fay b5daa24982 Android support (#299)
* AI libs registering shenanigans on android;
* Fixed resolution aspect + mouse event scaling;
* Proper server init/deinit (through android IPC);
Enabled threaded init in CMT;
* Prevented a deadlock in logger on some devices;
* Fixed frozen intro frame after interrupting the video;
Added android progressbar displaying during initial data loading;
* Hacky fix for choppy animations during heroes movement (should look better now, but it's definitely not a good solution);
* Changes/fixes for new android launcher building process;
* Fixed app hang after getting SDL_QUIT when activity was destroyed;
* Functioanal, configurable advmap swiping support;
* VCMI changes cleanup;
Added few missing VCMI_ANDROID guards on swipe mechanics;
* Removed unneeded sleep in server startup code for android;
* Removed android ioapi hack (fixed in newest ndk);
* Removed unused android's library loading logic;
* Added android's swipe option to settings schema;
* Moved NO_STD_TOSTRING to be defined in global.h instead of build files;
2017-05-25 20:57:20 +03:00

628 lines
19 KiB
C++

/*
* VCMIDirs.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "VCMIDirs.h"
namespace bfs = boost::filesystem;
bfs::path IVCMIDirs::userSavePath() const { return userDataPath() / "Saves"; }
bfs::path IVCMIDirs::fullLibraryPath(const std::string &desiredFolder, const std::string &baseLibName) const
{
return libraryPath() / desiredFolder / libraryName(baseLibName);
}
void IVCMIDirs::init()
{
// TODO: Log errors
bfs::create_directories(userDataPath());
bfs::create_directories(userCachePath());
bfs::create_directories(userConfigPath());
bfs::create_directories(userSavePath());
}
#ifdef VCMI_ANDROID
#include "CAndroidVMHelper.h"
#endif
#ifdef VCMI_WINDOWS
#ifdef __MINGW32__
#define _WIN32_IE 0x0500
#ifndef CSIDL_MYDOCUMENTS
#define CSIDL_MYDOCUMENTS CSIDL_PERSONAL
#endif
#endif // __MINGW32__
#include <windows.h>
#include <shlobj.h>
#include <shellapi.h>
// Generates script file named _temp.bat in 'to' directory and runs it
// Script will:
// - Wait util 'exeName' ends.
// - Copy all files from 'from' to 'to'
// - Ask user to replace files existed in 'to'.
// - Run 'exeName'
// - Delete itself.
bool StartBatchCopyDataProgram(
const bfs::path& from, const bfs::path& to, const bfs::path& exeName,
const bfs::path& currentPath = bfs::current_path())
{
static const char base[] =
"@echo off" "\n"
"echo Preparing to move VCMI data system." "\n"
":CLIENT_RUNNING_LOOP" "\n"
"TASKLIST | FIND /I %1% > nul" "\n"
"IF ERRORLEVEL 1 (" "\n"
"GOTO CLIENT_NOT_RUNNING" "\n"
") ELSE (" "\n"
"echo %1% is still running..." "\n"
"echo Waiting until process ends..." "\n"
"ping 1.1.1.1 -n 1 -w 3000 > nul" "\n" // Sleep ~3 seconds. I love Windows :)
"goto :CLIENT_RUNNING_LOOP" "\n"
")" "\n"
":CLIENT_NOT_RUNNING" "\n"
"echo %1% turned off..." "\n"
"echo Attempt to move datas." "\n"
"echo From: %2%" "\n"
"echo To: %4%" "\n"
"echo Please resolve any conflicts..." "\n"
"move /-Y %3% %4%" "\n" // Move all files from %3% to %4%.
// /-Y ask what to do when file exists in %4%
":REMOVE_OLD_DIR" "\n"
"rd %2% || rem" "\n" // Remove empty directory. Sets error flag if fail.
"IF ERRORLEVEL 145 (" "\n" // Directory not empty
"echo Directory %2% is not empty." "\n"
"echo Please move rest of files manually now." "\n"
"pause" "\n" // Press any key to continue...
"goto REMOVE_OLD_DIR" "\n"
")" "\n"
"echo Game data updated succefully." "\n"
"echo Please update your shortcuts." "\n"
"echo Press any key to start a game . . ." "\n"
"pause > nul" "\n"
"%5%" "\n"
"del \"%%~f0\"&exit" "\n" // Script deletes itself
;
const auto startGameString =
bfs::equivalent(currentPath, from) ?
(boost::format("start \"\" %1%") % (to / exeName)) : // Start game in new path.
(boost::format("start \"\" /D %1% %2%") % currentPath % (to / exeName)); // Start game in 'currentPath"
const bfs::path bathFilename = to / "_temp.bat";
bfs::ofstream bathFile(bathFilename, bfs::ofstream::trunc | bfs::ofstream::out);
if (!bathFile.is_open())
return false;
bathFile << (boost::format(base) % exeName % from % (from / "*.*") % to % startGameString.str()).str();
bathFile.close();
std::system(("start \"Updating VCMI datas\" /D \"" + to.string() + "\" \"" + bathFilename.string() + '\"').c_str());
// start won't block std::system
// /D start bat in other directory insteand of current directory.
return true;
}
class VCMIDirsWIN32 final : public IVCMIDirs
{
public:
boost::filesystem::path userDataPath() const override;
boost::filesystem::path userCachePath() const override;
boost::filesystem::path userConfigPath() const override;
std::vector<boost::filesystem::path> dataPaths() const override;
boost::filesystem::path clientPath() const override;
boost::filesystem::path serverPath() const override;
boost::filesystem::path libraryPath() const override;
boost::filesystem::path binaryPath() const override;
std::string libraryName(const std::string& basename) const override;
std::string genHelpString() const override;
void init() override;
protected:
boost::filesystem::path oldUserDataPath() const;
boost::filesystem::path oldUserSavePath() const;
};
void VCMIDirsWIN32::init()
{
// Call base (init dirs)
IVCMIDirs::init();
// Moves one directory (from) contents to another directory (to)
// Shows user the "moving file dialog" and ask to resolve conflits.
// If necessary updates current directory.
auto moveDirIfExists = [](const bfs::path& from, const bfs::path& to) -> bool
{
if (!bfs::is_directory(from))
return true; // Nothing to do here. Flies away.
if (bfs::is_empty(from))
{
if (bfs::current_path() == from)
bfs::current_path(to);
bfs::remove(from);
return true; // Nothing to do here. Flies away.
}
if (!bfs::is_directory(to))
{
// IVCMIDirs::init() should create all destination directories.
// TODO: Log fact, that we shouldn't be here.
bfs::create_directories(to);
}
// Why the hell path strings should be end with double null :/
auto makeDoubleNulled = [](const bfs::path& path) -> std::unique_ptr<wchar_t[]>
{
const std::wstring& pathStr = path.native();
std::unique_ptr<wchar_t[]> result(new wchar_t[pathStr.length() + 2]);
size_t i = 0;
for (const wchar_t ch : pathStr)
result[i++] = ch;
result[i++] = L'\0';
result[i++] = L'\0';
return result;
};
auto fromDNulled = makeDoubleNulled(from / L"*.*");
auto toDNulled = makeDoubleNulled(to);
SHFILEOPSTRUCTW fileOp;
fileOp.hwnd = GetConsoleWindow();
fileOp.wFunc = FO_MOVE;
fileOp.pFrom = fromDNulled.get();
fileOp.pTo = toDNulled.get();
fileOp.fFlags = 0;
fileOp.hNameMappings = nullptr;
fileOp.lpszProgressTitle = nullptr;
const int errorCode = SHFileOperationW(&fileOp);
if (errorCode != 0) // TODO: Log error. User should try to move files.
return false;
else if (fileOp.fAnyOperationsAborted) // TODO: Log warn. User aborted operation. User should move files.
return false;
else if (!bfs::is_empty(from)) // TODO: Log warn. Some files not moved. User should try to move files.
return false;
if (bfs::current_path() == from)
bfs::current_path(to);
// TODO: Log fact that we moved files succefully.
bfs::remove(from);
return true;
};
// Retrieves the fully qualified path for the file that contains the specified module.
// The module must have been loaded by the current process.
// If this parameter is nullptr, retrieves the path of the executable file of the current process.
auto getModulePath = [](HMODULE hModule) -> bfs::path
{
wchar_t exePathW[MAX_PATH];
DWORD nSize = GetModuleFileNameW(hModule, exePathW, MAX_PATH);
DWORD error = GetLastError();
// WARN: Windows XP don't set ERROR_INSUFFICIENT_BUFFER error.
if (nSize != 0 && error != ERROR_INSUFFICIENT_BUFFER)
return bfs::path(std::wstring(exePathW, nSize));
// TODO: Error handling
return bfs::path();
};
// Moves one directory contents to another directory
// Shows user the "moving file dialog" and ask to resolve conflicts.
// It takes into account that 'from' path can contain current executable.
// If necessary closes program and starts update script.
auto advancedMoveDirIfExists = [getModulePath, moveDirIfExists](const bfs::path& from, const bfs::path& to) -> bool
{
const bfs::path executablePath = getModulePath(nullptr);
// VCMI cann't determine executable path.
// Use standard way to move directory and exit function.
if (executablePath.empty())
return moveDirIfExists(from, to);
const bfs::path executableName = executablePath.filename();
// Current executabl isn't in 'from' path.
// Use standard way to move directory and exit function.
if (!bfs::equivalent(executablePath, from / executableName))
return moveDirIfExists(from, to);
// Try standard way to move directory.
// I don't know how other systems, but Windows 8.1 allow to move running executable.
if (moveDirIfExists(from, to))
return true;
// Start copying script and exit program.
if (StartBatchCopyDataProgram(from, to, executableName))
exit(ERROR_SUCCESS);
// Everything failed :C
return false;
};
moveDirIfExists(oldUserSavePath(), userSavePath());
advancedMoveDirIfExists(oldUserDataPath(), userDataPath());
}
bfs::path VCMIDirsWIN32::userDataPath() const
{
wchar_t profileDir[MAX_PATH];
if (SHGetSpecialFolderPathW(nullptr, profileDir, CSIDL_MYDOCUMENTS, FALSE) != FALSE)
return bfs::path(profileDir) / "My Games\\vcmi";
return ".";
}
bfs::path VCMIDirsWIN32::oldUserDataPath() const
{
wchar_t profileDir[MAX_PATH];
if (SHGetSpecialFolderPathW(nullptr, profileDir, CSIDL_PROFILE, FALSE) == FALSE) // WinAPI way failed
{
#if defined(_MSC_VER) && _MSC_VER >= 1700
wchar_t* buffer;
size_t bufferSize;
errno_t result = _wdupenv_s(&buffer, &bufferSize, L"userprofile");
if (result == 0)
{
bfs::path result(std::wstring(buffer, bufferSize));
free(buffer);
return result;
}
#else
const char* profileDirA;
if ((profileDirA = std::getenv("userprofile"))) // STL way succeed
return bfs::path(profileDirA) / "vcmi";
#endif
else
return "."; // Every thing failed, return current directory.
}
else
return bfs::path(profileDir) / "vcmi";
//return dataPaths()[0] ???;
}
bfs::path VCMIDirsWIN32::oldUserSavePath() const { return userDataPath() / "Games"; }
bfs::path VCMIDirsWIN32::userCachePath() const { return userDataPath(); }
bfs::path VCMIDirsWIN32::userConfigPath() const { return userDataPath() / "config"; }
std::vector<bfs::path> VCMIDirsWIN32::dataPaths() const
{
return std::vector<bfs::path>(1, bfs::path("."));
}
bfs::path VCMIDirsWIN32::clientPath() const { return binaryPath() / "VCMI_client.exe"; }
bfs::path VCMIDirsWIN32::serverPath() const { return binaryPath() / "VCMI_server.exe"; }
bfs::path VCMIDirsWIN32::libraryPath() const { return "."; }
bfs::path VCMIDirsWIN32::binaryPath() const { return "."; }
std::string VCMIDirsWIN32::genHelpString() const
{
std::vector<std::string> tempVec;
for (const bfs::path& path : dataPaths())
tempVec.push_back(path.string());
std::string gdStringA = boost::algorithm::join(tempVec, ";");
return
" game data: " + gdStringA + "\n"
" libraries: " + libraryPath().string() + "\n"
" server: " + serverPath().string() + "\n"
"\n"
" user data: " + userDataPath().string() + "\n"
" user cache: " + userCachePath().string() + "\n"
" user config: " + userConfigPath().string() + "\n"
" user saves: " + userSavePath().string() + "\n"; // Should end without new-line?
}
std::string VCMIDirsWIN32::libraryName(const std::string& basename) const { return basename + ".dll"; }
#elif defined(VCMI_UNIX)
class IVCMIDirsUNIX : public IVCMIDirs
{
public:
boost::filesystem::path clientPath() const override;
boost::filesystem::path serverPath() const override;
std::string genHelpString() const override;
};
bfs::path IVCMIDirsUNIX::clientPath() const { return binaryPath() / "vcmiclient"; }
bfs::path IVCMIDirsUNIX::serverPath() const { return binaryPath() / "vcmiserver"; }
std::string IVCMIDirsUNIX::genHelpString() const
{
std::vector<std::string> tempVec;
for (const bfs::path& path : dataPaths())
tempVec.push_back(path.string());
std::string gdStringA = boost::algorithm::join(tempVec, ":");
return
" game data: " + gdStringA + "\n"
" libraries: " + libraryPath().string() + "\n"
" server: " + serverPath().string() + "\n"
"\n"
" user data: " + userDataPath().string() + "\n"
" user cache: " + userCachePath().string() + "\n"
" user config: " + userConfigPath().string() + "\n"
" user saves: " + userSavePath().string() + "\n"; // Should end without new-line?
}
#ifdef VCMI_APPLE
class VCMIDirsOSX final : public IVCMIDirsUNIX
{
public:
boost::filesystem::path userDataPath() const override;
boost::filesystem::path userCachePath() const override;
boost::filesystem::path userConfigPath() const override;
std::vector<boost::filesystem::path> dataPaths() const override;
boost::filesystem::path libraryPath() const override;
boost::filesystem::path binaryPath() const override;
std::string libraryName(const std::string& basename) const override;
void init() override;
};
void VCMIDirsOSX::init()
{
// Call base (init dirs)
IVCMIDirsUNIX::init();
auto moveDirIfExists = [](const bfs::path& from, const bfs::path& to)
{
if (!bfs::is_directory(from))
return; // Nothing to do here. Flies away.
if (bfs::is_empty(from))
{
bfs::remove(from);
return; // Nothing to do here. Flies away.
}
if (!bfs::is_directory(to))
{
// IVCMIDirs::init() should create all destination directories.
// TODO: Log fact, that we shouldn't be here.
bfs::create_directories(to);
}
for (bfs::directory_iterator file(from); file != bfs::directory_iterator(); ++file)
{
const boost::filesystem::path& srcFilePath = file->path();
const boost::filesystem::path dstFilePath = to / srcFilePath.filename();
// TODO: Aplication should ask user what to do when file exists:
// replace/ignore/stop process/replace all/ignore all
if (!boost::filesystem::exists(dstFilePath))
bfs::rename(srcFilePath, dstFilePath);
}
if (!bfs::is_empty(from)); // TODO: Log warn. Some files not moved. User should try to move files.
else
bfs::remove(from);
};
moveDirIfExists(userDataPath() / "Games", userSavePath());
}
bfs::path VCMIDirsOSX::userDataPath() const
{
// This is Cocoa code that should be normally used to get path to Application Support folder but can't use it here for now...
// NSArray* urls = [[NSFileManager defaultManager] URLsForDirectory:NSApplicationSupportDirectory inDomains:NSUserDomainMask];
// UserPath = path([urls[0] path] + "/vcmi").string();
// ...so here goes a bit of hardcode instead
const char* homeDir = getenv("HOME"); // Should be std::getenv?
if (homeDir == nullptr)
homeDir = ".";
return bfs::path(homeDir) / "Library" / "Application Support" / "vcmi";
}
bfs::path VCMIDirsOSX::userCachePath() const { return userDataPath(); }
bfs::path VCMIDirsOSX::userConfigPath() const { return userDataPath() / "config"; }
std::vector<bfs::path> VCMIDirsOSX::dataPaths() const
{
return std::vector<bfs::path>(1, "../Data");
}
bfs::path VCMIDirsOSX::libraryPath() const { return "."; }
bfs::path VCMIDirsOSX::binaryPath() const { return "."; }
std::string VCMIDirsOSX::libraryName(const std::string& basename) const { return "lib" + basename + ".dylib"; }
#elif defined(VCMI_XDG)
class VCMIDirsXDG : public IVCMIDirsUNIX
{
public:
boost::filesystem::path userDataPath() const override;
boost::filesystem::path userCachePath() const override;
boost::filesystem::path userConfigPath() const override;
std::vector<boost::filesystem::path> dataPaths() const override;
boost::filesystem::path libraryPath() const override;
boost::filesystem::path binaryPath() const override;
std::string libraryName(const std::string& basename) const override;
};
bfs::path VCMIDirsXDG::userDataPath() const
{
// $XDG_DATA_HOME, default: $HOME/.local/share
const char* homeDir;
if ((homeDir = getenv("XDG_DATA_HOME")))
return homeDir;
else if ((homeDir = getenv("HOME")))
return bfs::path(homeDir) / ".local" / "share" / "vcmi";
else
return ".";
}
bfs::path VCMIDirsXDG::userCachePath() const
{
// $XDG_CACHE_HOME, default: $HOME/.cache
const char* tempResult;
if ((tempResult = getenv("XDG_CACHE_HOME")))
return bfs::path(tempResult) / "vcmi";
else if ((tempResult = getenv("HOME")))
return bfs::path(tempResult) / ".cache" / "vcmi";
else
return ".";
}
bfs::path VCMIDirsXDG::userConfigPath() const
{
// $XDG_CONFIG_HOME, default: $HOME/.config
const char* tempResult;
if ((tempResult = getenv("XDG_CONFIG_HOME")))
return bfs::path(tempResult) / "vcmi";
else if ((tempResult = getenv("HOME")))
return bfs::path(tempResult) / ".config" / "vcmi";
else
return ".";
}
std::vector<bfs::path> VCMIDirsXDG::dataPaths() const
{
// $XDG_DATA_DIRS, default: /usr/local/share/:/usr/share/
// construct list in reverse.
// in specification first directory has highest priority
// in vcmi fs last directory has highest priority
std::vector<bfs::path> ret;
const char* tempResult;
ret.push_back(M_DATA_DIR);
if ((tempResult = getenv("XDG_DATA_DIRS")) != nullptr)
{
std::string dataDirsEnv = tempResult;
std::vector<std::string> dataDirs;
boost::split(dataDirs, dataDirsEnv, boost::is_any_of(":"));
for (auto & entry : boost::adaptors::reverse(dataDirs))
ret.push_back(entry + "/vcmi");
}
else
{
ret.push_back("/usr/share/");
ret.push_back("/usr/local/share/");
}
return ret;
}
bfs::path VCMIDirsXDG::libraryPath() const { return M_LIB_DIR; }
bfs::path VCMIDirsXDG::binaryPath() const { return M_BIN_DIR; }
std::string VCMIDirsXDG::libraryName(const std::string& basename) const { return "lib" + basename + ".so"; }
#ifdef VCMI_ANDROID
class VCMIDirsAndroid : public VCMIDirsXDG
{
std::string basePath;
std::string internalPath;
std::string nativePath;
public:
bfs::path fullLibraryPath(const std::string & desiredFolder, const std::string & baseLibName) const override;
bfs::path libraryPath() const override;
bfs::path userDataPath() const override;
bfs::path userCachePath() const override;
bfs::path userConfigPath() const override;
std::vector<bfs::path> dataPaths() const override;
void init() override;
};
bfs::path VCMIDirsAndroid::libraryPath() const { return nativePath; }
bfs::path VCMIDirsAndroid::userDataPath() const { return basePath; }
bfs::path VCMIDirsAndroid::userCachePath() const { return userDataPath() / "cache"; }
bfs::path VCMIDirsAndroid::userConfigPath() const { return userDataPath() / "config"; }
bfs::path VCMIDirsAndroid::fullLibraryPath(const std::string & desiredFolder, const std::string & baseLibName) const
{
// ignore passed folder (all libraries in android are dumped into a single folder)
return libraryPath() / libraryName(baseLibName);
}
std::vector<bfs::path> VCMIDirsAndroid::dataPaths() const
{
std::vector<bfs::path> paths(2);
paths.push_back(internalPath);
paths.push_back(userDataPath());
return paths;
}
void VCMIDirsAndroid::init()
{
// asks java code to retrieve needed paths from environment
CAndroidVMHelper envHelper;
basePath = envHelper.callStaticStringMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "dataRoot");
internalPath = envHelper.callStaticStringMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "internalDataRoot");
nativePath = envHelper.callStaticStringMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "nativePath");
IVCMIDirs::init();
}
#endif // VCMI_ANDROID
#endif // VCMI_APPLE, VCMI_XDG
#endif // VCMI_WINDOWS, VCMI_UNIX
// Getters for interfaces are separated for clarity.
namespace VCMIDirs
{
const IVCMIDirs& get()
{
#ifdef VCMI_WINDOWS
static VCMIDirsWIN32 singleton;
#elif defined(VCMI_ANDROID)
static VCMIDirsAndroid singleton;
#elif defined(VCMI_XDG)
static VCMIDirsXDG singleton;
#elif defined(VCMI_APPLE)
static VCMIDirsOSX singleton;
#endif
static bool initialized = false;
if (!initialized)
{
#ifndef VCMI_ANDROID
std::locale::global(boost::locale::generator().generate("en_US.UTF-8"));
#endif
boost::filesystem::path::imbue(std::locale());
singleton.init();
initialized = true;
}
return singleton;
}
}