bool FilesPageHandler::listDirectory(Common::String path, Common::String &content, const Common::String &itemTemplate) {
if (path == "" || path == "/") {
if (ConfMan.hasKey("rootpath", "cloud"))
addItem(content, itemTemplate, IT_DIRECTORY, "/root/", _("File system root"));
addItem(content, itemTemplate, IT_DIRECTORY, "/saves/", _("Saved games"));
return true;
}
if (HandlerUtils::hasForbiddenCombinations(path))
return false;
Common::String prefixToRemove = "", prefixToAdd = "";
if (!transformPath(path, prefixToRemove, prefixToAdd))
return false;
Common::FSNode node = Common::FSNode(path);
if (path == "/")
node = node.getParent(); // absolute root
if (!HandlerUtils::permittedPath(node.getPath()))
return false;
if (!node.isDirectory())
return false;
// list directory
Common::FSList _nodeContent;
if (!node.getChildren(_nodeContent, Common::FSNode::kListAll, false)) // do not show hidden files
_nodeContent.clear();
else
Common::sort(_nodeContent.begin(), _nodeContent.end());
// add parent directory link
{
Common::String filePath = path;
if (filePath.hasPrefix(prefixToRemove))
filePath.erase(0, prefixToRemove.size());
if (filePath == "" || filePath == "/" || filePath == "\\")
filePath = "/";
else
filePath = parentPath(prefixToAdd + filePath);
addItem(content, itemTemplate, IT_PARENT_DIRECTORY, filePath, _("Parent directory"));
}
// fill the content
for (Common::FSList::iterator i = _nodeContent.begin(); i != _nodeContent.end(); ++i) {
Common::String name = i->getDisplayName();
if (i->isDirectory())
name += "/";
Common::String filePath = i->getPath();
if (filePath.hasPrefix(prefixToRemove))
filePath.erase(0, prefixToRemove.size());
filePath = prefixToAdd + filePath;
addItem(content, itemTemplate, detectType(i->isDirectory(), name), filePath, name);
}
return true;
}
void FMVScreen::play(const Common::String &name) {
Common::SeekableReadStream *stream = nullptr;
// Play the low-resolution video, if possible
if (!StarkSettings->getBoolSetting(Settings::kHighFMV) && StarkSettings->hasLowResFMV()) {
Common::String lowResName = name;
lowResName.erase(lowResName.size() - 4);
lowResName += "_lo_res.bbb";
stream = StarkArchiveLoader->getExternalFile(lowResName, "Global/");
if (!stream) {
debug("Could not open %s", lowResName.c_str());
}
}
// Play the original video
if (!stream) {
stream = StarkArchiveLoader->getExternalFile(name, "Global/");
}
if (!stream) {
warning("Could not open %s", name.c_str());
return;
}
_decoder->loadStream(stream);
if (!_decoder->isVideoLoaded()) {
error("Could not open %s", name.c_str());
}
_decoder->start();
}
void Music::getSongNames(Common::StringArray &songs) {
songs.clear();
if (IS_SERRATED_SCALPEL) {
if (IS_3DO) {
Common::FSDirectory gameDirectory(ConfMan.get("path"));
Common::FSDirectory *musicDirectory = gameDirectory.getSubDirectory("music");
Common::ArchiveMemberList files;
musicDirectory->listMatchingMembers(files, "*_mw22.aifc");
for (Common::ArchiveMemberList::iterator i = files.begin(); i != files.end(); ++i) {
Common::String name = (*i)->getName();
name.erase(name.size() - 10);
songs.push_back(name);
}
} else {
for (int i = 0; i < ARRAYSIZE(SONG_NAMES); i++) {
songs.push_back(SONG_NAMES[i]);
}
}
} else {
Common::StringArray fileList;
_vm->_res->getResourceNames("music.lib", fileList);
for (Common::StringArray::iterator i = fileList.begin(); i != fileList.end(); ++i) {
if ((*i).matchString("*.XMI", true)) {
(*i).erase((*i).size() - 4);
songs.push_back(*i);
}
}
}
Common::sort(songs.begin(), songs.end());
}
void IdCreateDirectoryRequest::idResolveFailedCallback(Networking::ErrorResponse error) {
_workingRequest = nullptr;
if (_ignoreCallback)
return;
if (error.request)
_date = error.request->date();
//not resolved => folder not exists
if (error.response.contains("no such file found in its parent directory")) {
//parent's id after the '\n'
Common::String parentId = error.response;
for (uint32 i = 0; i < parentId.size(); ++i)
if (parentId[i] == '\n') {
parentId.erase(0, i + 1);
break;
}
Storage::BoolCallback callback = new Common::Callback<IdCreateDirectoryRequest, Storage::BoolResponse>(this, &IdCreateDirectoryRequest::createdDirectoryCallback);
Networking::ErrorCallback failureCallback = new Common::Callback<IdCreateDirectoryRequest, Networking::ErrorResponse>(this, &IdCreateDirectoryRequest::createdDirectoryErrorCallback);
_workingRequest = _storage->createDirectoryWithParentId(parentId, _requestedDirectoryName, callback, failureCallback);
return;
}
finishError(error);
}
void PDAMgr::calculateIndexes() {
Common::String country = Common::String::format("%.3s", _page->getName().c_str());
for (uint i = 0; i < 6; ++i) {
if (country == g_countries[i]) {
_countryIndex = i;
break;
}
}
Common::String domain = _page->getName();
domain.erase(0, 3);
if (domain.size() >= 4)
domain.erase(3);
for (uint i = 0; i < 8; ++i) {
if (domain == g_domains[i]) {
_domainIndex = i;
break;
}
}
}
void FolderDownloadRequest::downloadNextFile() {
do {
if (_pendingFiles.empty()) {
sendCommand(GUI::kDownloadEndedCmd, 0);
finishDownload(_failedFiles);
return;
}
_currentFile = _pendingFiles.back();
_pendingFiles.pop_back();
} while (_currentFile.isDirectory()); // directories are actually removed earlier, in the directoryListedCallback()
sendCommand(GUI::kDownloadProgressCmd, (int)(getProgress() * 100));
Common::String remotePath = _currentFile.path();
Common::String localPath = remotePath;
if (_remoteDirectoryPath == "" || remotePath.hasPrefix(_remoteDirectoryPath)) {
localPath.erase(0, _remoteDirectoryPath.size());
if (_remoteDirectoryPath != "" && (_remoteDirectoryPath.lastChar() != '/' && _remoteDirectoryPath.lastChar() != '\\'))
localPath.erase(0, 1);
} else {
warning("FolderDownloadRequest: Can't process the following paths:");
warning("remote directory: %s", _remoteDirectoryPath.c_str());
warning("remote file under that directory: %s", remotePath.c_str());
}
if (_localDirectoryPath != "") {
if (_localDirectoryPath.lastChar() == '/' || _localDirectoryPath.lastChar() == '\\')
localPath = _localDirectoryPath + localPath;
else
localPath = _localDirectoryPath + "/" + localPath;
}
debug(9, "FolderDownloadRequest: %s -> %s", remotePath.c_str(), localPath.c_str());
_workingRequest = _storage->downloadById(
_currentFile.id(), localPath,
new Common::Callback<FolderDownloadRequest, Storage::BoolResponse>(this, &FolderDownloadRequest::fileDownloadedCallback),
new Common::Callback<FolderDownloadRequest, Networking::ErrorResponse>(this, &FolderDownloadRequest::fileDownloadedErrorCallback)
);
}
Networking::Request *IdStorage::createDirectory(Common::String path, BoolCallback callback, Networking::ErrorCallback errorCallback) {
if (!errorCallback)
errorCallback = getErrorPrintingCallback();
if (!callback)
callback = new Common::Callback<IdStorage, BoolResponse>(this, &IdStorage::printBool);
//find out the parent path and directory name
Common::String parentPath = "", directoryName = path;
for (uint32 i = path.size(); i > 0; --i) {
if (path[i - 1] == '/' || path[i - 1] == '\\') {
parentPath = path;
parentPath.erase(i - 1);
directoryName.erase(0, i);
break;
}
}
return addRequest(new IdCreateDirectoryRequest(this, parentPath, directoryName, callback, errorCallback));
}
void RemoteBrowserDialog::goUp() {
if (_rememberedNodeContents.contains(_node.path()))
_rememberedNodeContents.erase(_node.path());
Common::String path = _node.path();
if (path.size() && (path.lastChar() == '/' || path.lastChar() == '\\'))
path.deleteLastChar();
if (path.empty()) {
_rememberedNodeContents.erase("");
} else {
for (int i = path.size() - 1; i >= 0; --i)
if (i == 0 || path[i] == '/' || path[i] == '\\') {
path.erase(i);
break;
}
}
listDirectory(Cloud::StorageFile(path, 0, 0, true));
}
bool DumpFile::open(const String &filename, bool createPath) {
assert(!filename.empty());
assert(!_handle);
if (createPath) {
for (uint32 i = 0; i < filename.size(); ++i) {
if (filename[i] == '/' || filename[i] == '\\') {
Common::String subpath = filename;
subpath.erase(i);
if (subpath.empty()) continue;
AbstractFSNode *node = g_system->getFilesystemFactory()->makeFileNodePath(subpath);
if (node->exists()) continue;
if (!node->create(true)) warning("DumpFile: unable to create directories from path prefix");
}
}
}
FSNode node(filename);
return open(node);
}
void IdCreateDirectoryRequest::start() {
//cleanup
_ignoreCallback = true;
if (_workingRequest)
_workingRequest->finish();
_workingRequest = nullptr;
_ignoreCallback = false;
//the only exception when we create parent folder - is when it's ScummVM/ base folder
Common::String prefix = _requestedParentPath;
if (prefix.size() > 7)
prefix.erase(7);
if (prefix.equalsIgnoreCase("ScummVM")) {
Storage::BoolCallback callback = new Common::Callback<IdCreateDirectoryRequest, Storage::BoolResponse>(this, &IdCreateDirectoryRequest::createdBaseDirectoryCallback);
Networking::ErrorCallback failureCallback = new Common::Callback<IdCreateDirectoryRequest, Networking::ErrorResponse>(this, &IdCreateDirectoryRequest::createdBaseDirectoryErrorCallback);
_workingRequest = _storage->createDirectory("ScummVM", callback, failureCallback);
return;
}
resolveId();
}
void GoogleDriveUploadRequest::idResolveFailedCallback(Networking::ErrorResponse error) {
_workingRequest = nullptr;
if (_ignoreCallback)
return;
//not resolved => error or no such file
if (error.response.contains("no such file found in its parent directory")) {
//parent's id after the '\n'
Common::String parentId = error.response;
for (uint32 i = 0; i < parentId.size(); ++i)
if (parentId[i] == '\n') {
parentId.erase(0, i + 1);
break;
}
_parentId = parentId;
startUpload();
return;
}
finishError(error);
}
void GoogleDriveUploadRequest::startUpload() {
Common::String name = _savePath;
for (uint32 i = name.size(); i > 0; --i) {
if (name[i - 1] == '/' || name[i - 1] == '\\') {
name.erase(0, i);
break;
}
}
Common::String url = GOOGLEDRIVE_API_FILES;
if (_resolvedId != "")
url += "/" + ConnMan.urlEncode(_resolvedId);
url += "?uploadType=resumable&fields=id,mimeType,modifiedTime,name,size";
Networking::JsonCallback callback = new Common::Callback<GoogleDriveUploadRequest, Networking::JsonResponse>(this, &GoogleDriveUploadRequest::startUploadCallback);
Networking::ErrorCallback failureCallback = new Common::Callback<GoogleDriveUploadRequest, Networking::ErrorResponse>(this, &GoogleDriveUploadRequest::startUploadErrorCallback);
Networking::CurlJsonRequest *request = new GoogleDriveTokenRefresher(_storage, callback, failureCallback, url.c_str());
request->addHeader("Authorization: Bearer " + _storage->accessToken());
request->addHeader("Content-Type: application/json");
if (_resolvedId != "")
request->usePatch();
Common::JSONObject jsonRequestParameters;
if (_resolvedId != "") {
jsonRequestParameters.setVal("id", new Common::JSONValue(_resolvedId));
} else {
Common::JSONArray parentsArray;
parentsArray.push_back(new Common::JSONValue(_parentId));
jsonRequestParameters.setVal("parents", new Common::JSONValue(parentsArray));
}
jsonRequestParameters.setVal("name", new Common::JSONValue(name));
Common::JSONValue value(jsonRequestParameters);
request->addPostField(Common::JSON::stringify(&value));
_workingRequest = ConnMan.addRequest(request);
}
