scummvm/backends/cloud/cloudmanager.cpp

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/

#include "backends/cloud/cloudmanager.h"
#include "backends/cloud/dropbox/dropboxstorage.h"
#include "backends/cloud/onedrive/onedrivestorage.h"
#include "backends/cloud/googledrive/googledrivestorage.h"
#include "common/config-manager.h"
#include "common/debug.h"
#include "common/translation.h"

namespace Common {

DECLARE_SINGLETON(Cloud::CloudManager);

}

namespace Cloud {

CloudManager::CloudManager() : _currentStorageIndex(0), _activeStorage(nullptr) {}

CloudManager::~CloudManager() {
	//TODO: do we have to save storages on manager destruction?	
	delete _activeStorage;
}

namespace {
uint64 atoull(Common::String s) {
	uint64 result = 0;
	for (uint32 i = 0; i < s.size(); ++i) {
		if (s[i] < '0' || s[i] > '9') break;
		result = result * 10L + (s[i] - '0');
	}
	return result;
}
}

Common::String CloudManager::getStorageConfigName(uint32 index) const {
	switch (index) {
	case kStorageNoneId: return "<none>";
	case kStorageDropboxId: return "Dropbox";
	case kStorageOneDriveId: return "OneDrive";
	case kStorageGoogleDriveId: return "GoogleDrive";
	}
	return "Unknown";
}

void CloudManager::loadStorage() {
	switch (_currentStorageIndex) {
	case kStorageDropboxId:
		_activeStorage = Dropbox::DropboxStorage::loadFromConfig("storage_" + getStorageConfigName(_currentStorageIndex) + "_");
		break;

	case kStorageOneDriveId:
		_activeStorage = OneDrive::OneDriveStorage::loadFromConfig("storage_" + getStorageConfigName(_currentStorageIndex) + "_");
		break;

	case kStorageGoogleDriveId:
		_activeStorage = GoogleDrive::GoogleDriveStorage::loadFromConfig("storage_" + getStorageConfigName(_currentStorageIndex) + "_");
		break;

	default:
		_activeStorage = nullptr;
	}

	if (!_activeStorage) {
		_currentStorageIndex = kStorageNoneId;
	}
}

void CloudManager::init() {
	//init configs structs
	for (uint32 i = 0; i < kStorageTotal; ++i) {
		Common::String name = getStorageConfigName(i);
		StorageConfig config;
		config.name = _(name);
		config.username = "";
		config.lastSyncDate = "";
		config.usedBytes = 0;
		if (ConfMan.hasKey("storage_" + name + "_username", "cloud"))
			config.username = ConfMan.get("storage_" + name + "_username", "cloud");
		if (ConfMan.hasKey("storage_" + name + "_lastSync", "cloud"))
			config.lastSyncDate = ConfMan.get("storage_" + name + "_lastSync", "cloud");
		if (ConfMan.hasKey("storage_" + name + "_usedBytes", "cloud"))
			config.usedBytes = atoull(ConfMan.get("storage_" + name + "_usedBytes", "cloud"));
		_storages.push_back(config);
	}

	//load an active storage if there is any
	_currentStorageIndex = kStorageNoneId;
	if (ConfMan.hasKey("current_storage", "cloud"))
		_currentStorageIndex = ConfMan.getInt("current_storage", "cloud");

	loadStorage();
}

void CloudManager::save() {
	ConfMan.set("current_storage", Common::String::format("%d", _currentStorageIndex), "cloud");
	if (_activeStorage)
		_activeStorage->saveConfig("storage_" + getStorageConfigName(_currentStorageIndex) + "_");
	ConfMan.flushToDisk();
}

void CloudManager::replaceStorage(Storage *storage, uint32 index) {
	if (!storage) error("CloudManager::replaceStorage: NULL storage passed");
	if (index >= kStorageTotal) error("CloudManager::replaceStorage: invalid index passed");
	delete _activeStorage;
	_activeStorage = storage;
	_currentStorageIndex = index;
	save();
}

Storage *CloudManager::getCurrentStorage() const {
	return _activeStorage;
}

uint32 CloudManager::getStorageIndex() const {
	return _currentStorageIndex;
}

Common::StringArray CloudManager::listStorages() const {
	Common::StringArray result;
	for (uint32 i = 0; i < _storages.size(); ++i) {
		result.push_back(_storages[i].name);
	}
	return result;
}

bool CloudManager::switchStorage(uint32 index) {
	if (index >= _storages.size()) {
		warning("CloudManager::switchStorage: invalid index passed");
		return false;
	}

	Storage *storage = getCurrentStorage();
	if (storage && storage->isWorking()) {
		warning("CloudManager::switchStorage: another storage is working now");
		return false;
	}

	_currentStorageIndex = index;
	loadStorage();
	save();
	return true;
}

Common::String CloudManager::getStorageUsername(uint32 index) {
	if (index >= _storages.size()) return "";
	return _storages[index].username;
}

uint64 CloudManager::getStorageUsedSpace(uint32 index) {
	if (index >= _storages.size()) return 0;
	return _storages[index].usedBytes;
}

Common::String CloudManager::getStorageLastSync(uint32 index) {
	if (index >= _storages.size()) return "";
	if (index == _currentStorageIndex && isSyncing()) return "";
	return _storages[index].lastSyncDate;
}

void CloudManager::printBool(Storage::BoolResponse response) const {
	debug("bool = %s", (response.value ? "true" : "false"));
}

SavesSyncRequest *CloudManager::syncSaves(Storage::BoolCallback callback, Networking::ErrorCallback errorCallback) {
	Storage *storage = getCurrentStorage();
	if (storage) return storage->syncSaves(callback, errorCallback);
	return nullptr;
}

void CloudManager::testFeature() {
	Storage *storage = getCurrentStorage();
	//if (storage) storage->info(nullptr, nullptr);
	GoogleDrive::GoogleDriveStorage *gd = dynamic_cast<GoogleDrive::GoogleDriveStorage *>(storage);
	if (gd) {
	}
		//gd->resolveFileId("firstfolder/subfolder", nullptr, nullptr);
		//gd->listDirectoryById("appDataFolder", nullptr, nullptr);
		//gd->listDirectoryById("1LWq-r1IwegkJJ0eZpswGlyjj8nu6XyUmosvxD7L0F9X3", nullptr, nullptr);
		//gd->createDirectoryWithParentId("1LWq-r1IwegkJJ0eZpswGlyjj8nu6XyUmosvxD7L0F9X3", "subfolder", nullptr, nullptr);
		//gd->createDirectoryWithParentId("appDataFolder", "firstfolder", nullptr, nullptr);
	else debug("FAILURE");
}

bool CloudManager::isWorking() {
	Storage *storage = getCurrentStorage();
	if (storage) return storage->isWorking();
	return false;
}

bool CloudManager::isSyncing() {
	Storage *storage = getCurrentStorage();
	if (storage) return storage->isSyncing();
	return false;
}

double CloudManager::getSyncDownloadingProgress() {
	Storage *storage = getCurrentStorage();
	if (storage) return storage->getSyncDownloadingProgress();
	return 1;
}

double CloudManager::getSyncProgress() {
	Storage *storage = getCurrentStorage();
	if (storage) return storage->getSyncProgress();
	return 1;
}

Common::Array<Common::String> CloudManager::getSyncingFiles() {
	Storage *storage = getCurrentStorage();
	if (storage) return storage->getSyncingFiles();
	return Common::Array<Common::String>();
}

void CloudManager::cancelSync() {
	Storage *storage = getCurrentStorage();
	if (storage) storage->cancelSync();
}

void CloudManager::setSyncTarget(GUI::CommandReceiver *target) {
	Storage *storage = getCurrentStorage();
	if (storage) storage->setSyncTarget(target);
}

} // End of namespace Common