mirror of
https://github.com/vcmi/vcmi.git
synced 2024-12-22 22:13:35 +02:00
718 lines
22 KiB
C++
718 lines
22 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"
|
|
|
|
#ifdef VCMI_IOS
|
|
#include "iOS_utils.h"
|
|
#elif defined(VCMI_ANDROID)
|
|
#include "CAndroidVMHelper.h"
|
|
#endif
|
|
|
|
VCMI_LIB_NAMESPACE_BEGIN
|
|
|
|
namespace bfs = boost::filesystem;
|
|
|
|
bfs::path IVCMIDirs::userLogsPath() const { return userCachePath(); }
|
|
|
|
bfs::path IVCMIDirs::userSavePath() const { return userDataPath() / "Saves"; }
|
|
|
|
bfs::path IVCMIDirs::userExtractedPath() const { return userCachePath() / "extracted"; }
|
|
|
|
bfs::path IVCMIDirs::fullLibraryPath(const std::string &desiredFolder, const std::string &baseLibName) const
|
|
{
|
|
return libraryPath() / desiredFolder / libraryName(baseLibName);
|
|
}
|
|
|
|
std::string IVCMIDirs::genHelpString() const
|
|
{
|
|
std::vector<std::string> tempVec;
|
|
for (const bfs::path & path : dataPaths())
|
|
tempVec.push_back(path.string());
|
|
const auto 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 logs: " + userLogsPath().string() + "\n"
|
|
" user saves: " + userSavePath().string() + "\n"
|
|
" user extracted: " + userExtractedPath().string() + "\n";
|
|
}
|
|
|
|
void IVCMIDirs::init()
|
|
{
|
|
// TODO: Log errors
|
|
bfs::create_directories(userDataPath());
|
|
bfs::create_directories(userCachePath());
|
|
bfs::create_directories(userConfigPath());
|
|
bfs::create_directories(userLogsPath());
|
|
bfs::create_directories(userSavePath());
|
|
}
|
|
|
|
#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:
|
|
bfs::path userDataPath() const override;
|
|
bfs::path userCachePath() const override;
|
|
bfs::path userConfigPath() const override;
|
|
|
|
std::vector<bfs::path> dataPaths() const override;
|
|
|
|
bfs::path clientPath() const override;
|
|
bfs::path mapEditorPath() const override;
|
|
bfs::path serverPath() const override;
|
|
|
|
bfs::path libraryPath() const override;
|
|
bfs::path binaryPath() const override;
|
|
|
|
std::string libraryName(const std::string& basename) const override;
|
|
|
|
void init() override;
|
|
protected:
|
|
bfs::path oldUserDataPath() const;
|
|
bfs::path oldUserSavePath() const;
|
|
};
|
|
|
|
void VCMIDirsWIN32::init()
|
|
{
|
|
std::locale::global(boost::locale::generator().generate("en_US.UTF-8"));
|
|
boost::filesystem::path::imbue(std::locale());
|
|
|
|
// 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::mapEditorPath() const { return binaryPath() / "VCMI_mapeditor.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::libraryName(const std::string& basename) const { return basename + ".dll"; }
|
|
#elif defined(VCMI_UNIX)
|
|
class IVCMIDirsUNIX : public IVCMIDirs
|
|
{
|
|
public:
|
|
bfs::path clientPath() const override;
|
|
bfs::path mapEditorPath() const override;
|
|
bfs::path serverPath() const override;
|
|
|
|
virtual bool developmentMode() const;
|
|
};
|
|
|
|
bool IVCMIDirsUNIX::developmentMode() const
|
|
{
|
|
// We want to be able to run VCMI from single directory. E.g to run from build output directory
|
|
const bool hasConfigs = bfs::exists("config") && bfs::exists("Mods");
|
|
const bool hasBinaries = bfs::exists("vcmiclient") || bfs::exists("vcmiserver") || bfs::exists("vcmilobby");
|
|
return hasConfigs && hasBinaries;
|
|
}
|
|
|
|
bfs::path IVCMIDirsUNIX::clientPath() const { return binaryPath() / "vcmiclient"; }
|
|
bfs::path IVCMIDirsUNIX::mapEditorPath() const { return binaryPath() / "vcmieditor"; }
|
|
bfs::path IVCMIDirsUNIX::serverPath() const { return binaryPath() / "vcmiserver"; }
|
|
|
|
#ifdef VCMI_APPLE
|
|
class VCMIDirsApple : public IVCMIDirsUNIX
|
|
{
|
|
public:
|
|
bfs::path userConfigPath() const override;
|
|
|
|
std::string libraryName(const std::string& basename) const override;
|
|
};
|
|
|
|
bfs::path VCMIDirsApple::userConfigPath() const { return userDataPath() / "config"; }
|
|
|
|
std::string VCMIDirsApple::libraryName(const std::string& basename) const { return "lib" + basename + ".dylib"; }
|
|
|
|
#ifdef VCMI_IOS
|
|
class VCMIDirsIOS final : public VCMIDirsApple
|
|
{
|
|
public:
|
|
bfs::path userDataPath() const override;
|
|
bfs::path userCachePath() const override;
|
|
bfs::path userLogsPath() const override;
|
|
|
|
std::vector<bfs::path> dataPaths() const override;
|
|
|
|
bfs::path libraryPath() const override;
|
|
bfs::path fullLibraryPath(const std::string & desiredFolder, const std::string & baseLibName) const override;
|
|
bfs::path binaryPath() const override;
|
|
};
|
|
|
|
bfs::path VCMIDirsIOS::userDataPath() const { return {iOS_utils::documentsPath()}; }
|
|
bfs::path VCMIDirsIOS::userCachePath() const { return {iOS_utils::cachesPath()}; }
|
|
bfs::path VCMIDirsIOS::userLogsPath() const { return {iOS_utils::documentsPath()}; }
|
|
|
|
std::vector<bfs::path> VCMIDirsIOS::dataPaths() const
|
|
{
|
|
std::vector<bfs::path> paths;
|
|
paths.reserve(4);
|
|
#ifdef VCMI_IOS_SIM
|
|
paths.emplace_back(iOS_utils::hostApplicationSupportPath());
|
|
#endif
|
|
paths.emplace_back(userDataPath());
|
|
paths.emplace_back(iOS_utils::documentsPath());
|
|
paths.emplace_back(binaryPath());
|
|
return paths;
|
|
}
|
|
|
|
bfs::path VCMIDirsIOS::fullLibraryPath(const std::string & desiredFolder, const std::string & baseLibName) const
|
|
{
|
|
// iOS has flat libs directory structure
|
|
return libraryPath() / libraryName(baseLibName);
|
|
}
|
|
|
|
bfs::path VCMIDirsIOS::libraryPath() const { return {iOS_utils::frameworksPath()}; }
|
|
bfs::path VCMIDirsIOS::binaryPath() const { return {iOS_utils::bundlePath()}; }
|
|
#elif defined(VCMI_MAC)
|
|
class VCMIDirsOSX final : public VCMIDirsApple
|
|
{
|
|
public:
|
|
bfs::path userDataPath() const override;
|
|
bfs::path userCachePath() const override;
|
|
bfs::path userLogsPath() const override;
|
|
|
|
std::vector<bfs::path> dataPaths() const override;
|
|
|
|
bfs::path libraryPath() const override;
|
|
bfs::path binaryPath() 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 bfs::path& srcFilePath = file->path();
|
|
const bfs::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 (!bfs::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::userLogsPath() const
|
|
{
|
|
// TODO: use proper objc code from Foundation framework
|
|
if(const auto homeDir = std::getenv("HOME"))
|
|
return bfs::path{homeDir} / "Library" / "Logs" / "vcmi";
|
|
return IVCMIDirsUNIX::userLogsPath();
|
|
}
|
|
|
|
std::vector<bfs::path> VCMIDirsOSX::dataPaths() const
|
|
{
|
|
std::vector<bfs::path> ret;
|
|
//FIXME: need some proper codepath for detecting running from build output directory
|
|
if(developmentMode())
|
|
{
|
|
ret.push_back(".");
|
|
}
|
|
else
|
|
{
|
|
ret.push_back("../Resources/Data");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bfs::path VCMIDirsOSX::libraryPath() const { return "."; }
|
|
bfs::path VCMIDirsOSX::binaryPath() const { return "."; }
|
|
#endif // VCMI_IOS, VCMI_MAC
|
|
|
|
#elif defined(VCMI_ANDROID)
|
|
class VCMIDirsAndroid : public IVCMIDirsUNIX
|
|
{
|
|
std::string basePath;
|
|
std::string internalPath;
|
|
std::string nativePath;
|
|
public:
|
|
std::string libraryName(const std::string & basename) const override;
|
|
bfs::path fullLibraryPath(const std::string & desiredFolder, const std::string & baseLibName) const override;
|
|
bfs::path binaryPath() 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;
|
|
};
|
|
|
|
std::string VCMIDirsAndroid::libraryName(const std::string & basename) const { return "lib" + basename + ".so"; }
|
|
bfs::path VCMIDirsAndroid::binaryPath() const { return "."; }
|
|
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
|
|
{
|
|
return {
|
|
internalPath,
|
|
userDataPath(),
|
|
};
|
|
}
|
|
|
|
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");
|
|
IVCMIDirsUNIX::init();
|
|
}
|
|
#elif defined(VCMI_XDG)
|
|
class VCMIDirsXDG : public IVCMIDirsUNIX
|
|
{
|
|
public:
|
|
bfs::path userDataPath() const override;
|
|
bfs::path userCachePath() const override;
|
|
bfs::path userConfigPath() const override;
|
|
|
|
std::vector<bfs::path> dataPaths() const override;
|
|
|
|
bfs::path libraryPath() const override;
|
|
bfs::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 bfs::path(homeDir) / "vcmi";
|
|
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 = getenv("XDG_CONFIG_HOME");
|
|
if (tempResult)
|
|
return bfs::path(tempResult) / "vcmi";
|
|
|
|
tempResult = getenv("HOME");
|
|
if (tempResult)
|
|
return bfs::path(tempResult) / ".config" / "vcmi";
|
|
|
|
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;
|
|
|
|
if(developmentMode())
|
|
{
|
|
//For now we'll disable usage of system directories when VCMI running from bin directory
|
|
ret.emplace_back(".");
|
|
}
|
|
else
|
|
{
|
|
ret.emplace_back(M_DATA_DIR);
|
|
const char * tempResult;
|
|
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(bfs::path(entry) / "vcmi");
|
|
}
|
|
else
|
|
{
|
|
ret.push_back(bfs::path("/usr/share") / "vcmi");
|
|
ret.push_back(bfs::path("/usr/local/share") / "vcmi");
|
|
}
|
|
|
|
// Debian and other distributions might want to use it while it's not part of XDG
|
|
ret.push_back(bfs::path("/usr/share/games") / "vcmi");
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bfs::path VCMIDirsXDG::libraryPath() const
|
|
{
|
|
if(developmentMode())
|
|
return ".";
|
|
else
|
|
return M_LIB_DIR;
|
|
}
|
|
|
|
bfs::path VCMIDirsXDG::binaryPath() const
|
|
{
|
|
if(developmentMode())
|
|
return ".";
|
|
else
|
|
return M_BIN_DIR;
|
|
}
|
|
|
|
std::string VCMIDirsXDG::libraryName(const std::string& basename) const { return "lib" + basename + ".so"; }
|
|
|
|
#endif // VCMI_APPLE, VCMI_ANDROID, 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_MAC)
|
|
static VCMIDirsOSX singleton;
|
|
#elif defined(VCMI_IOS)
|
|
static VCMIDirsIOS singleton;
|
|
#endif
|
|
|
|
static std::once_flag flag;
|
|
std::call_once(flag, [] { singleton.init(); });
|
|
return singleton;
|
|
}
|
|
}
|
|
|
|
VCMI_LIB_NAMESPACE_END
|