mirror/qBittorrent
2
0
Fork 0
mirror of https://github.com/qbittorrent/qBittorrent.git synced 2025-01-30 18:50:11 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'optimize-persistent-data' of git://github.com/sorokin/qBittorrent

Browse Source 
Conflicts:
	src/qtlibtorrent/qbtsession.cpp
This commit is contained in:
sledgehammer999 2015-01-27 15:21:26 +02:00
commit dcf5d4d0ee
10 changed files with 165 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/mainwindow.cpp
View File

@ -63,7 +63,6 @@
#include "preferences.h" #include "preferences.h"
#include "trackerlist.h" #include "trackerlist.h"
#include "peerlistwidget.h" #include "peerlistwidget.h"
#include "torrentpersistentdata.h"
#include "transferlistfilterswidget.h" #include "transferlistfilterswidget.h"
#include "propertieswidget.h" #include "propertieswidget.h"
#include "statusbar.h" #include "statusbar.h"
@ -668,7 +667,7 @@ void MainWindow::balloonClicked()
// called when a torrent has finished // called when a torrent has finished
void MainWindow::finishedTorrent(const QTorrentHandle& h) const void MainWindow::finishedTorrent(const QTorrentHandle& h) const
{ {
if (TorrentPersistentData::isSeed(h.hash())) if (TorrentPersistentData::instance().isSeed(h.hash()))
showNotificationBaloon(tr("Download completion"), tr("%1 has finished downloading.", "e.g: xxx.avi has finished downloading.").arg(h.name())); showNotificationBaloon(tr("Download completion"), tr("%1 has finished downloading.", "e.g: xxx.avi has finished downloading.").arg(h.name()));
} }

2
src/mainwindow.h
View File

@ -36,6 +36,7 @@
#include <QPointer> #include <QPointer>
#include "ui_mainwindow.h" #include "ui_mainwindow.h"
#include "qtorrenthandle.h" #include "qtorrenthandle.h"
#include "torrentpersistentdata.h"
#include "statsdialog.h" #include "statsdialog.h"
class QBtSession; class QBtSession;
@ -216,6 +217,7 @@ private:
bool has_python; bool has_python;
#endif #endif
QMenu* toolbarMenu; QMenu* toolbarMenu;
TorrentPersistentData persistentData;
private slots: private slots:
void on_actionSearch_engine_triggered(); void on_actionSearch_engine_triggered();

84
src/qtlibtorrent/qbtsession.cpp
View File

@ -227,7 +227,7 @@ void QBtSession::processBigRatios() {
if (h.is_seed()) { if (h.is_seed()) {
const QString hash = h.hash(); const QString hash = h.hash();
const qreal ratio = getRealRatio(h.status(torrent_handle::query_accurate_download_counters)); const qreal ratio = getRealRatio(h.status(torrent_handle::query_accurate_download_counters));
qreal ratio_limit = TorrentPersistentData::getRatioLimit(hash); qreal ratio_limit = TorrentPersistentData::instance().getRatioLimit(hash);
if (ratio_limit == TorrentPersistentData::USE_GLOBAL_RATIO) if (ratio_limit == TorrentPersistentData::USE_GLOBAL_RATIO)
ratio_limit = global_ratio_limit; ratio_limit = global_ratio_limit;
if (ratio_limit == TorrentPersistentData::NO_RATIO_LIMIT) if (ratio_limit == TorrentPersistentData::NO_RATIO_LIMIT)
@ -830,7 +830,7 @@ void QBtSession::deleteTorrent(const QString &hash, bool delete_local_files) {
foreach (const QString &file, files) { foreach (const QString &file, files) {
fsutils::forceRemove(torrentBackup.absoluteFilePath(file)); fsutils::forceRemove(torrentBackup.absoluteFilePath(file));
} }
TorrentPersistentData::deletePersistentData(hash); TorrentPersistentData::instance().deletePersistentData(hash);
TorrentTempData::deleteTempData(hash); TorrentTempData::deleteTempData(hash);
HiddenData::deleteData(hash); HiddenData::deleteData(hash);
// Remove tracker errors // Remove tracker errors
@ -981,7 +981,7 @@ QTorrentHandle QBtSession::addMagnetUri(QString magnet_uri, bool resumed, bool f
} }
if (savePath.isEmpty()) if (savePath.isEmpty())
savePath = getSavePath(hash, false); savePath = getSavePath(hash, false);
if (!defaultTempPath.isEmpty() && !TorrentPersistentData::isSeed(hash)) { if (!defaultTempPath.isEmpty() && !TorrentPersistentData::instance().isSeed(hash)) {
qDebug("addMagnetURI: Temp folder is enabled."); qDebug("addMagnetURI: Temp folder is enabled.");
QString torrent_tmp_path = defaultTempPath; QString torrent_tmp_path = defaultTempPath;
p.save_path = fsutils::toNativePath(torrent_tmp_path).toUtf8().constData(); p.save_path = fsutils::toNativePath(torrent_tmp_path).toUtf8().constData();
@ -1175,7 +1175,7 @@ QTorrentHandle QBtSession::addTorrent(QString path, bool fromScanDir, QString fr
} else { } else {
savePath = getSavePath(hash, fromScanDir, path, imported); savePath = getSavePath(hash, fromScanDir, path, imported);
} }
if (!imported && !defaultTempPath.isEmpty() && !TorrentPersistentData::isSeed(hash)) { if (!imported && !defaultTempPath.isEmpty() && !TorrentPersistentData::instance().isSeed(hash)) {
qDebug("addTorrent::Temp folder is enabled."); qDebug("addTorrent::Temp folder is enabled.");
QString torrent_tmp_path = defaultTempPath; QString torrent_tmp_path = defaultTempPath;
p.save_path = fsutils::toNativePath(torrent_tmp_path).toUtf8().constData(); p.save_path = fsutils::toNativePath(torrent_tmp_path).toUtf8().constData();
@ -1340,9 +1340,9 @@ void QBtSession::loadTorrentTempData(QTorrentHandle &h, QString savePath, bool m
// Save persistent data for new torrent // Save persistent data for new torrent
qDebug("Saving torrent persistant data"); qDebug("Saving torrent persistant data");
if (defaultTempPath.isEmpty()) if (defaultTempPath.isEmpty())
TorrentPersistentData::saveTorrentPersistentData(h, QString::null, magnet); TorrentPersistentData::instance().saveTorrentPersistentData(h, QString::null, magnet);
else else
TorrentPersistentData::saveTorrentPersistentData(h, fsutils::fromNativePath(savePath), magnet); TorrentPersistentData::instance().saveTorrentPersistentData(h, fsutils::fromNativePath(savePath), magnet);
} }
void QBtSession::mergeTorrents(QTorrentHandle& h_ex, const QString& magnet_uri) void QBtSession::mergeTorrents(QTorrentHandle& h_ex, const QString& magnet_uri)
@ -1661,7 +1661,7 @@ void QBtSession::saveFastResumeData() {
continue; continue;
try { try {
if (isQueueingEnabled()) if (isQueueingEnabled())
TorrentPersistentData::savePriority(h); TorrentPersistentData::instance().savePriority(h);
if (!h.has_metadata()) if (!h.has_metadata())
continue; continue;
// Actually with should save fast resume data for paused files too // Actually with should save fast resume data for paused files too
@ -1850,7 +1850,7 @@ void QBtSession::appendqBextensionToTorrent(const QTorrentHandle &h, bool append
void QBtSession::changeLabelInTorrentSavePath(const QTorrentHandle &h, QString old_label, QString new_label) { void QBtSession::changeLabelInTorrentSavePath(const QTorrentHandle &h, QString old_label, QString new_label) {
if (!h.is_valid()) return; if (!h.is_valid()) return;
if (!appendLabelToSavePath) return; if (!appendLabelToSavePath) return;
QString old_save_path = fsutils::fromNativePath(TorrentPersistentData::getSavePath(h.hash())); QString old_save_path = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(h.hash()));
if (!old_save_path.startsWith(defaultSavePath)) return; if (!old_save_path.startsWith(defaultSavePath)) return;
QString new_save_path = fsutils::updateLabelInSavePath(defaultSavePath, old_save_path, old_label, new_label); QString new_save_path = fsutils::updateLabelInSavePath(defaultSavePath, old_save_path, old_label, new_label);
if (new_save_path != old_save_path) { if (new_save_path != old_save_path) {
@ -1863,10 +1863,10 @@ void QBtSession::changeLabelInTorrentSavePath(const QTorrentHandle &h, QString o
void QBtSession::appendLabelToTorrentSavePath(const QTorrentHandle& h) { void QBtSession::appendLabelToTorrentSavePath(const QTorrentHandle& h) {
if (!h.is_valid()) return; if (!h.is_valid()) return;
const QString label = TorrentPersistentData::getLabel(h.hash()); const QString label = TorrentPersistentData::instance().getLabel(h.hash());
if (label.isEmpty()) return; if (label.isEmpty()) return;
// Current save path // Current save path
QString old_save_path = fsutils::fromNativePath(TorrentPersistentData::getSavePath(h.hash())); QString old_save_path = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(h.hash()));
QString new_save_path = fsutils::updateLabelInSavePath(defaultSavePath, old_save_path, "", label); QString new_save_path = fsutils::updateLabelInSavePath(defaultSavePath, old_save_path, "", label);
if (old_save_path != new_save_path) { if (old_save_path != new_save_path) {
// Move storage // Move storage
@ -1992,20 +1992,20 @@ void QBtSession::setMaxRatioPerTorrent(const QString &hash, qreal ratio)
ratio = MAX_RATIO; ratio = MAX_RATIO;
qDebug("* Set individual max ratio for torrent %s to %.1f.", qDebug("* Set individual max ratio for torrent %s to %.1f.",
qPrintable(hash), ratio); qPrintable(hash), ratio);
TorrentPersistentData::setRatioLimit(hash, ratio); TorrentPersistentData::instance().setRatioLimit(hash, ratio);
updateRatioTimer(); updateRatioTimer();
} }
void QBtSession::removeRatioPerTorrent(const QString &hash) void QBtSession::removeRatioPerTorrent(const QString &hash)
{ {
qDebug("* Remove individual max ratio for torrent %s.", qPrintable(hash)); qDebug("* Remove individual max ratio for torrent %s.", qPrintable(hash));
TorrentPersistentData::setRatioLimit(hash, TorrentPersistentData::USE_GLOBAL_RATIO); TorrentPersistentData::instance().setRatioLimit(hash, TorrentPersistentData::USE_GLOBAL_RATIO);
updateRatioTimer(); updateRatioTimer();
} }
qreal QBtSession::getMaxRatioPerTorrent(const QString &hash, bool *usesGlobalRatio) const qreal QBtSession::getMaxRatioPerTorrent(const QString &hash, bool *usesGlobalRatio) const
{ {
qreal ratio_limit = TorrentPersistentData::getRatioLimit(hash); qreal ratio_limit = TorrentPersistentData::instance().getRatioLimit(hash);
if (ratio_limit == TorrentPersistentData::USE_GLOBAL_RATIO) { if (ratio_limit == TorrentPersistentData::USE_GLOBAL_RATIO) {
ratio_limit = global_ratio_limit; ratio_limit = global_ratio_limit;
if (usesGlobalRatio) if (usesGlobalRatio)
@ -2019,7 +2019,7 @@ qreal QBtSession::getMaxRatioPerTorrent(const QString &hash, bool *usesGlobalRat
void QBtSession::updateRatioTimer() void QBtSession::updateRatioTimer()
{ {
if (global_ratio_limit == -1 && !TorrentPersistentData::hasPerTorrentRatioLimit()) { if (global_ratio_limit == -1 && !TorrentPersistentData::instance().hasPerTorrentRatioLimit()) {
if (BigRatioTimer->isActive()) if (BigRatioTimer->isActive())
BigRatioTimer->stop(); BigRatioTimer->stop();
} else if (!BigRatioTimer->isActive()) { } else if (!BigRatioTimer->isActive()) {
@ -2099,7 +2099,7 @@ void QBtSession::sendNotificationEmail(const QTorrentHandle &h) {
// Prepare mail content // Prepare mail content
QString content = tr("Torrent name: %1").arg(h.name()) + "\n"; QString content = tr("Torrent name: %1").arg(h.name()) + "\n";
content += tr("Torrent size: %1").arg(misc::friendlyUnit(status.total_wanted)) + "\n"; content += tr("Torrent size: %1").arg(misc::friendlyUnit(status.total_wanted)) + "\n";
content += tr("Save path: %1").arg(TorrentPersistentData::getSavePath(h.hash())) + "\n\n"; content += tr("Save path: %1").arg(TorrentPersistentData::instance().getSavePath(h.hash())) + "\n\n";
content += tr("The torrent was downloaded in %1.", "The torrent was downloaded in 1 hour and 20 seconds").arg(misc::userFriendlyDuration(status.active_time)) + "\n\n\n"; content += tr("The torrent was downloaded in %1.", "The torrent was downloaded in 1 hour and 20 seconds").arg(misc::userFriendlyDuration(status.active_time)) + "\n\n\n";
content += tr("Thank you for using qBittorrent.") + "\n"; content += tr("Thank you for using qBittorrent.") + "\n";
// Send the notification email // Send the notification email
@ -2213,7 +2213,7 @@ void QBtSession::handleTorrentFinishedAlert(libtorrent::torrent_finished_alert*
if (appendqBExtension) if (appendqBExtension)
appendqBextensionToTorrent(h, false); appendqBextensionToTorrent(h, false);
const bool was_already_seeded = TorrentPersistentData::isSeed(hash); const bool was_already_seeded = TorrentPersistentData::instance().isSeed(hash);
qDebug("Was already seeded: %d", was_already_seeded); qDebug("Was already seeded: %d", was_already_seeded);
if (!was_already_seeded) { if (!was_already_seeded) {
h.save_resume_data(); h.save_resume_data();
@ -2256,7 +2256,7 @@ void QBtSession::handleTorrentFinishedAlert(libtorrent::torrent_finished_alert*
} }
// Remember finished state // Remember finished state
qDebug("Saving seed status"); qDebug("Saving seed status");
TorrentPersistentData::saveSeedStatus(h); TorrentPersistentData::instance().saveSeedStatus(h);
// Recheck if the user asked to // Recheck if the user asked to
Preferences* const pref = Preferences::instance(); Preferences* const pref = Preferences::instance();
if (pref->recheckTorrentsOnCompletion()) { if (pref->recheckTorrentsOnCompletion()) {
@ -2418,7 +2418,7 @@ void QBtSession::handleStorageMovedAlert(libtorrent::storage_moved_alert* p) {
} }
if (defaultTempPath.isEmpty() || !new_save_path.startsWith(defaultTempPath)) { if (defaultTempPath.isEmpty() || !new_save_path.startsWith(defaultTempPath)) {
qDebug("Storage has been moved, updating save path to %s", qPrintable(new_save_path)); qDebug("Storage has been moved, updating save path to %s", qPrintable(new_save_path));
TorrentPersistentData::saveSavePath(h.hash(), new_save_path); TorrentPersistentData::instance().saveSavePath(h.hash(), new_save_path);
} }
emit savePathChanged(h); emit savePathChanged(h);
//h.force_recheck(); //h.force_recheck();
@ -2657,11 +2657,11 @@ void QBtSession::handleFastResumeRejectedAlert(libtorrent::fastresume_rejected_a
QTorrentHandle h(p->handle); QTorrentHandle h(p->handle);
if (h.is_valid()) { if (h.is_valid()) {
qDebug("/!\\ Fast resume failed for %s, reason: %s", qPrintable(h.name()), p->message().c_str()); qDebug("/!\\ Fast resume failed for %s, reason: %s", qPrintable(h.name()), p->message().c_str());
if (p->error.value() == 134 && TorrentPersistentData::isSeed(h.hash()) && h.has_missing_files()) { if (p->error.value() == 134 && TorrentPersistentData::instance().isSeed(h.hash()) && h.has_missing_files()) {
const QString hash = h.hash(); const QString hash = h.hash();
// Mismatching file size (files were probably moved // Mismatching file size (files were probably moved
logger->addMessage(tr("File sizes mismatch for torrent %1, pausing it.").arg(h.name())); logger->addMessage(tr("File sizes mismatch for torrent %1, pausing it.").arg(h.name()));
TorrentPersistentData::setErrorState(hash, true); TorrentPersistentData::instance().setErrorState(hash, true);
pauseTorrent(hash); pauseTorrent(hash);
} else { } else {
logger->addMessage(tr("Fast resume data was rejected for torrent %1, checking again...").arg(h.name()), Log::CRITICAL); logger->addMessage(tr("Fast resume data was rejected for torrent %1, checking again...").arg(h.name()), Log::CRITICAL);
@ -2723,7 +2723,7 @@ void QBtSession::handleTorrentCheckedAlert(libtorrent::torrent_checked_alert* p)
const QString hash = h.hash(); const QString hash = h.hash();
qDebug("%s have just finished checking", qPrintable(hash)); qDebug("%s have just finished checking", qPrintable(hash));
// Save seed status // Save seed status
TorrentPersistentData::saveSeedStatus(h); TorrentPersistentData::instance().saveSeedStatus(h);
// Move to temp directory if necessary // Move to temp directory if necessary
if (!h.is_seed() && !defaultTempPath.isEmpty()) { if (!h.is_seed() && !defaultTempPath.isEmpty()) {
// Check if directory is different // Check if directory is different
@ -2846,7 +2846,7 @@ QString QBtSession::getSavePath(const QString &hash, bool fromScanDir, QString f
} }
qDebug("getSavePath, got save_path from temp data: %s", qPrintable(savePath)); qDebug("getSavePath, got save_path from temp data: %s", qPrintable(savePath));
} else { } else {
savePath = fsutils::fromNativePath(TorrentPersistentData::getSavePath(hash)); savePath = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash));
qDebug("SavePath got from persistant data is %s", qPrintable(savePath)); qDebug("SavePath got from persistant data is %s", qPrintable(savePath));
if (savePath.isEmpty()) { if (savePath.isEmpty()) {
if (fromScanDir && m_scanFolders->downloadInTorrentFolder(filePath)) { if (fromScanDir && m_scanFolders->downloadInTorrentFolder(filePath)) {
@ -2856,7 +2856,7 @@ QString QBtSession::getSavePath(const QString &hash, bool fromScanDir, QString f
} }
} }
if (!fromScanDir && appendLabelToSavePath) { if (!fromScanDir && appendLabelToSavePath) {
const QString label = TorrentPersistentData::getLabel(hash); const QString label = TorrentPersistentData::instance().getLabel(hash);
if (!label.isEmpty()) { if (!label.isEmpty()) {
qDebug("Torrent label is %s", qPrintable(label)); qDebug("Torrent label is %s", qPrintable(label));
savePath = fsutils::updateLabelInSavePath(defaultSavePath, savePath, "", label); savePath = fsutils::updateLabelInSavePath(defaultSavePath, savePath, "", label);
@ -3011,7 +3011,7 @@ qreal QBtSession::getPayloadUploadRate() const {
void QBtSession::startUpTorrents() { void QBtSession::startUpTorrents() {
qDebug("Resuming unfinished torrents"); qDebug("Resuming unfinished torrents");
const QDir torrentBackup(fsutils::BTBackupLocation()); const QDir torrentBackup(fsutils::BTBackupLocation());
const QStringList known_torrents = TorrentPersistentData::knownTorrents(); const QStringList known_torrents = TorrentPersistentData::instance().knownTorrents();
// Safety measure because some people reported torrent loss since // Safety measure because some people reported torrent loss since
// we switch the v1.5 way of resuming torrents on startup // we switch the v1.5 way of resuming torrents on startup
@ -3032,7 +3032,7 @@ void QBtSession::startUpTorrents() {
if (isQueueingEnabled()) { if (isQueueingEnabled()) {
priority_queue<QPair<int, QString>, vector<QPair<int, QString> >, std::greater<QPair<int, QString> > > torrent_queue; priority_queue<QPair<int, QString>, vector<QPair<int, QString> >, std::greater<QPair<int, QString> > > torrent_queue;
foreach (const QString &hash, known_torrents) { foreach (const QString &hash, known_torrents) {
const int prio = TorrentPersistentData::getPriority(hash); const int prio = TorrentPersistentData::instance().getPriority(hash);
torrent_queue.push(qMakePair(prio, hash)); torrent_queue.push(qMakePair(prio, hash));
} }
qDebug("Priority_queue size: %ld", (long)torrent_queue.size()); qDebug("Priority_queue size: %ld", (long)torrent_queue.size());
@ -3041,8 +3041,8 @@ void QBtSession::startUpTorrents() {
const QString hash = torrent_queue.top().second; const QString hash = torrent_queue.top().second;
torrent_queue.pop(); torrent_queue.pop();
qDebug("Starting up torrent %s", qPrintable(hash)); qDebug("Starting up torrent %s", qPrintable(hash));
if (TorrentPersistentData::isMagnet(hash)) { if (TorrentPersistentData::instance().isMagnet(hash)) {
addMagnetUri(TorrentPersistentData::getMagnetUri(hash), true); addMagnetUri(TorrentPersistentData::instance().getMagnetUri(hash), true);
} else { } else {
addTorrent(torrentBackup.path()+"/"+hash+".torrent", false, QString(), true); addTorrent(torrentBackup.path()+"/"+hash+".torrent", false, QString(), true);
} }
@ -3051,8 +3051,8 @@ void QBtSession::startUpTorrents() {
// Resume downloads // Resume downloads
foreach (const QString &hash, known_torrents) { foreach (const QString &hash, known_torrents) {
qDebug("Starting up torrent %s", qPrintable(hash)); qDebug("Starting up torrent %s", qPrintable(hash));
if (TorrentPersistentData::isMagnet(hash)) if (TorrentPersistentData::instance().isMagnet(hash))
addMagnetUri(TorrentPersistentData::getMagnetUri(hash), true); addMagnetUri(TorrentPersistentData::instance().getMagnetUri(hash), true);
else else
addTorrent(torrentBackup.path()+"/"+hash+".torrent", false, QString(), true); addTorrent(torrentBackup.path()+"/"+hash+".torrent", false, QString(), true);
} }
@ -3106,7 +3106,7 @@ void QBtSession::handleIPFilterError()
} }
void QBtSession::recoverPersistentData(const QString &hash, const std::vector<char> &buf) { void QBtSession::recoverPersistentData(const QString &hash, const std::vector<char> &buf) {
if (TorrentPersistentData::isKnownTorrent(hash) || TorrentTempData::hasTempData(hash) || buf.empty()) if (TorrentPersistentData::instance().isKnownTorrent(hash) || TorrentTempData::hasTempData(hash) || buf.empty())
return; return;
libtorrent::lazy_entry fast; libtorrent::lazy_entry fast;
@ -3123,20 +3123,20 @@ void QBtSession::recoverPersistentData(const QString &hash, const std::vector<ch
int priority = fast.dict_find_int_value("qBt-queuePosition"); int priority = fast.dict_find_int_value("qBt-queuePosition");
bool seedStatus = fast.dict_find_int_value("qBt-seedStatus"); bool seedStatus = fast.dict_find_int_value("qBt-seedStatus");
TorrentPersistentData::saveSavePath(hash, savePath); TorrentPersistentData::instance().saveSavePath(hash, savePath);
TorrentPersistentData::setRatioLimit(hash, ratioLimit); TorrentPersistentData::instance().setRatioLimit(hash, ratioLimit);
TorrentPersistentData::setAddedDate(hash, addedDate); TorrentPersistentData::instance().setAddedDate(hash, addedDate);
TorrentPersistentData::saveLabel(hash, label); TorrentPersistentData::instance().saveLabel(hash, label);
TorrentPersistentData::savePriority(hash, priority); TorrentPersistentData::instance().savePriority(hash, priority);
TorrentPersistentData::saveSeedStatus(hash, seedStatus); TorrentPersistentData::instance().saveSeedStatus(hash, seedStatus);
} }
void QBtSession::backupPersistentData(const QString &hash, boost::shared_ptr<libtorrent::entry> data) { void QBtSession::backupPersistentData(const QString &hash, boost::shared_ptr<libtorrent::entry> data) {
(*data)["qBt-savePath"] = fsutils::fromNativePath(TorrentPersistentData::getSavePath(hash)).toUtf8().constData(); (*data)["qBt-savePath"] = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash)).toUtf8().constData();
(*data)["qBt-ratioLimit"] = QString::number(TorrentPersistentData::getRatioLimit(hash)).toUtf8().constData(); (*data)["qBt-ratioLimit"] = QString::number(TorrentPersistentData::instance().getRatioLimit(hash)).toUtf8().constData();
(*data)["qBt-label"] = TorrentPersistentData::getLabel(hash).toUtf8().constData(); (*data)["qBt-label"] = TorrentPersistentData::instance().getLabel(hash).toUtf8().constData();
(*data)["qBt-queuePosition"] = TorrentPersistentData::getPriority(hash); (*data)["qBt-queuePosition"] = TorrentPersistentData::instance().getPriority(hash);
(*data)["qBt-seedStatus"] = (int)TorrentPersistentData::isSeed(hash); (*data)["qBt-seedStatus"] = (int)TorrentPersistentData::instance().isSeed(hash);
} }
void QBtSession::unhideMagnet(const QString &hash) { void QBtSession::unhideMagnet(const QString &hash) {
@ -3191,7 +3191,7 @@ void QBtSession::unhideMagnet(const QString &hash) {
} }
h.queue_position_bottom(); h.queue_position_bottom();
loadTorrentTempData(h, h.save_path(), !h.has_metadata()); //TempData are deleted by a call to TorrentPersistentData::saveTorrentPersistentData() loadTorrentTempData(h, h.save_path(), !h.has_metadata()); //TempData are deleted by a call to TorrentPersistentData::instance().saveTorrentPersistentData()
if (!add_paused) if (!add_paused)
h.resume(); h.resume();
h.move_storage(save_path); h.move_storage(save_path);

14
src/qtlibtorrent/qtorrenthandle.cpp
View File

@ -86,7 +86,7 @@ QString QTorrentHandle::hash() const
QString QTorrentHandle::name() const QString QTorrentHandle::name() const
{ {
QString name = TorrentPersistentData::getName(hash()); QString name = TorrentPersistentData::instance().getName(hash());
if (name.isEmpty()) { if (name.isEmpty()) {
#if LIBTORRENT_VERSION_NUM < 10000 #if LIBTORRENT_VERSION_NUM < 10000
name = misc::toQStringU(torrent_handle::name()); name = misc::toQStringU(torrent_handle::name());
@ -201,7 +201,7 @@ QString QTorrentHandle::save_path_parsed() const
p = firstFileSavePath(); p = firstFileSavePath();
} }
else { else {
p = fsutils::fromNativePath(TorrentPersistentData::getSavePath(hash())); p = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash()));
if (p.isEmpty()) if (p.isEmpty())
p = save_path(); p = save_path();
} }
@ -386,7 +386,7 @@ bool QTorrentHandle::priv() const
QString QTorrentHandle::firstFileSavePath() const QString QTorrentHandle::firstFileSavePath() const
{ {
Q_ASSERT(has_metadata()); Q_ASSERT(has_metadata());
QString fsave_path = fsutils::fromNativePath(TorrentPersistentData::getSavePath(hash())); QString fsave_path = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash()));
if (fsave_path.isEmpty()) if (fsave_path.isEmpty())
fsave_path = save_path(); fsave_path = save_path();
if (!fsave_path.endsWith("/")) if (!fsave_path.endsWith("/"))
@ -520,13 +520,13 @@ void QTorrentHandle::resume() const
torrent_handle::clear_error(); torrent_handle::clear_error();
const QString torrent_hash = hash(); const QString torrent_hash = hash();
bool has_persistant_error = TorrentPersistentData::hasError(torrent_hash); bool has_persistant_error = TorrentPersistentData::instance().hasError(torrent_hash);
TorrentPersistentData::setErrorState(torrent_hash, false); TorrentPersistentData::instance().setErrorState(torrent_hash, false);
bool temp_path_enabled = Preferences::instance()->isTempPathEnabled(); bool temp_path_enabled = Preferences::instance()->isTempPathEnabled();
if (has_persistant_error && temp_path_enabled) { if (has_persistant_error && temp_path_enabled) {
// Torrent was supposed to be seeding, checking again in final destination // Torrent was supposed to be seeding, checking again in final destination
qDebug("Resuming a torrent with error..."); qDebug("Resuming a torrent with error...");
const QString final_save_path = TorrentPersistentData::getSavePath(torrent_hash); const QString final_save_path = TorrentPersistentData::instance().getSavePath(torrent_hash);
qDebug("Torrent final path is: %s", qPrintable(final_save_path)); qDebug("Torrent final path is: %s", qPrintable(final_save_path));
if (!final_save_path.isEmpty()) if (!final_save_path.isEmpty())
move_storage(final_save_path); move_storage(final_save_path);
@ -691,7 +691,7 @@ void QTorrentHandle::prioritize_files(const vector<int> &files) const
if (was_seed && !is_seed()) { if (was_seed && !is_seed()) {
qDebug() << "Torrent is no longer SEEDING"; qDebug() << "Torrent is no longer SEEDING";
// Save seed status // Save seed status
TorrentPersistentData::saveSeedStatus(*this); TorrentPersistentData::instance().saveSeedStatus(*this);
// Move to temp folder if necessary // Move to temp folder if necessary
const Preferences* const pref = Preferences::instance(); const Preferences* const pref = Preferences::instance();
if (pref->isTempPathEnabled()) { if (pref->isTempPathEnabled()) {

10
src/qtlibtorrent/torrentmodel.cpp
View File

@ -84,9 +84,9 @@ QIcon get_error_icon() {
TorrentModelItem::TorrentModelItem(const QTorrentHandle &h) TorrentModelItem::TorrentModelItem(const QTorrentHandle &h)
: m_torrent(h) : m_torrent(h)
, m_lastStatus(h.status(torrent_handle::query_accurate_download_counters)) , m_lastStatus(h.status(torrent_handle::query_accurate_download_counters))
, m_addedTime(TorrentPersistentData::getAddedDate(h.hash())) , m_addedTime(TorrentPersistentData::instance().getAddedDate(h.hash()))
, m_label(TorrentPersistentData::getLabel(h.hash())) , m_label(TorrentPersistentData::instance().getLabel(h.hash()))
, m_name(TorrentPersistentData::getName(h.hash())) , m_name(TorrentPersistentData::instance().getName(h.hash()))
, m_hash(h.hash()) , m_hash(h.hash())
{ {
if (m_name.isEmpty()) if (m_name.isEmpty())
@ -202,14 +202,14 @@ bool TorrentModelItem::setData(int column, const QVariant &value, int role)
switch(column) { switch(column) {
case TR_NAME: case TR_NAME:
m_name = value.toString(); m_name = value.toString();
TorrentPersistentData::saveName(m_torrent.hash(), m_name); TorrentPersistentData::instance().saveName(m_torrent.hash(), m_name);
return true; return true;
case TR_LABEL: { case TR_LABEL: {
QString new_label = value.toString(); QString new_label = value.toString();
if (m_label != new_label) { if (m_label != new_label) {
QString old_label = m_label; QString old_label = m_label;
m_label = new_label; m_label = new_label;
TorrentPersistentData::saveLabel(m_torrent.hash(), new_label); TorrentPersistentData::instance().saveLabel(m_torrent.hash(), new_label);
emit labelChanged(old_label, new_label); emit labelChanged(old_label, new_label);
} }
return true; return true;

117
src/torrentpersistentdata.cpp
View File

@ -44,6 +44,7 @@ QHash<QString, TorrentTempData::TorrentData> TorrentTempData::data = QHash<QStri
QHash<QString, TorrentTempData::TorrentMoveState> TorrentTempData::torrentMoveStates = QHash<QString, TorrentTempData::TorrentMoveState>(); QHash<QString, TorrentTempData::TorrentMoveState> TorrentTempData::torrentMoveStates = QHash<QString, TorrentTempData::TorrentMoveState>();
QHash<QString, bool> HiddenData::data = QHash<QString, bool>(); QHash<QString, bool> HiddenData::data = QHash<QString, bool>();
unsigned int HiddenData::metadata_counter = 0; unsigned int HiddenData::metadata_counter = 0;
TorrentPersistentData* TorrentPersistentData::m_instance = 0;
bool TorrentTempData::hasTempData(const QString &hash) { bool TorrentTempData::hasTempData(const QString &hash) {
return data.contains(hash); return data.contains(hash);
@ -197,37 +198,51 @@ void HiddenData::gotMetadata(const QString &hash) {
metadata_counter++; metadata_counter++;
} }
TorrentPersistentData::TorrentPersistentData()
: all_data(QIniSettings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume")).value("torrents").toHash())
, dirty(false)
{
connect(&timer, SIGNAL(timeout()), SLOT(saveImpl()));
m_instance = this;
}
TorrentPersistentData::~TorrentPersistentData() {
save();
m_instance = 0;
}
void TorrentPersistentData::save() {
if (dirty)
saveImpl();
}
TorrentPersistentData& TorrentPersistentData::instance()
{
Q_ASSERT(m_instance);
return *m_instance;
}
bool TorrentPersistentData::isKnownTorrent(QString hash) { bool TorrentPersistentData::isKnownTorrent(QString hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
return all_data.contains(hash); return all_data.contains(hash);
} }
QStringList TorrentPersistentData::knownTorrents() { QStringList TorrentPersistentData::knownTorrents() {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
return all_data.keys(); return all_data.keys();
} }
void TorrentPersistentData::setRatioLimit(const QString &hash, const qreal &ratio) { void TorrentPersistentData::setRatioLimit(const QString &hash, const qreal &ratio) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data.value(hash).toHash(); QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["max_ratio"] = ratio; data["max_ratio"] = ratio;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
} }
qreal TorrentPersistentData::getRatioLimit(const QString &hash) { qreal TorrentPersistentData::getRatioLimit(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("max_ratio", USE_GLOBAL_RATIO).toReal(); return data.value("max_ratio", USE_GLOBAL_RATIO).toReal();
} }
bool TorrentPersistentData::hasPerTorrentRatioLimit() { bool TorrentPersistentData::hasPerTorrentRatioLimit() {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant>::ConstIterator it = all_data.constBegin(); QHash<QString, QVariant>::ConstIterator it = all_data.constBegin();
QHash<QString, QVariant>::ConstIterator itend = all_data.constEnd(); QHash<QString, QVariant>::ConstIterator itend = all_data.constEnd();
for ( ; it != itend; ++it) { for ( ; it != itend; ++it) {
@ -239,19 +254,15 @@ bool TorrentPersistentData::hasPerTorrentRatioLimit() {
} }
void TorrentPersistentData::setAddedDate(const QString &hash, const QDateTime &time) { void TorrentPersistentData::setAddedDate(const QString &hash, const QDateTime &time) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data.value(hash).toHash(); QHash<QString, QVariant> data = all_data.value(hash).toHash();
if (!data.contains("add_date")) { if (!data.contains("add_date")) {
data["add_date"] = time; data["add_date"] = time;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
} }
} }
QDateTime TorrentPersistentData::getAddedDate(const QString &hash) { QDateTime TorrentPersistentData::getAddedDate(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
QDateTime dt = data.value("add_date").toDateTime(); QDateTime dt = data.value("add_date").toDateTime();
if (!dt.isValid()) { if (!dt.isValid()) {
@ -262,34 +273,26 @@ QDateTime TorrentPersistentData::getAddedDate(const QString &hash) {
} }
void TorrentPersistentData::setErrorState(const QString &hash, const bool has_error) { void TorrentPersistentData::setErrorState(const QString &hash, const bool has_error) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data.value(hash).toHash(); QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["has_error"] = has_error; data["has_error"] = has_error;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
} }
bool TorrentPersistentData::hasError(const QString &hash) { bool TorrentPersistentData::hasError(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("has_error", false).toBool(); return data.value("has_error", false).toBool();
} }
QDateTime TorrentPersistentData::getSeedDate(const QString &hash) { QDateTime TorrentPersistentData::getSeedDate(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("seed_date").toDateTime(); return data.value("seed_date").toDateTime();
} }
void TorrentPersistentData::deletePersistentData(const QString &hash) { void TorrentPersistentData::deletePersistentData(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
if (all_data.contains(hash)) { if (all_data.contains(hash)) {
all_data.remove(hash); all_data.remove(hash);
settings.setValue("torrents", all_data); markDirty();
} }
} }
@ -297,8 +300,6 @@ void TorrentPersistentData::saveTorrentPersistentData(const QTorrentHandle &h, c
Q_ASSERT(h.is_valid()); Q_ASSERT(h.is_valid());
qDebug("Saving persistent data for %s", qPrintable(h.hash())); qDebug("Saving persistent data for %s", qPrintable(h.hash()));
// Save persistent data // Save persistent data
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data.value(h.hash()).toHash(); QHash<QString, QVariant> data = all_data.value(h.hash()).toHash();
data["is_magnet"] = is_magnet; data["is_magnet"] = is_magnet;
if (is_magnet) { if (is_magnet) {
@ -317,7 +318,7 @@ void TorrentPersistentData::saveTorrentPersistentData(const QTorrentHandle &h, c
data["label"] = TorrentTempData::getLabel(h.hash()); data["label"] = TorrentTempData::getLabel(h.hash());
// Save data // Save data
all_data[h.hash()] = data; all_data[h.hash()] = data;
settings.setValue("torrents", all_data); markDirty();
qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(h.hash())); qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(h.hash()));
// Set Added date // Set Added date
setAddedDate(h.hash(), QDateTime::currentDateTime()); setAddedDate(h.hash(), QDateTime::currentDateTime());
@ -328,121 +329,109 @@ void TorrentPersistentData::saveTorrentPersistentData(const QTorrentHandle &h, c
void TorrentPersistentData::saveSavePath(const QString &hash, const QString &save_path) { void TorrentPersistentData::saveSavePath(const QString &hash, const QString &save_path) {
Q_ASSERT(!hash.isEmpty()); Q_ASSERT(!hash.isEmpty());
qDebug("TorrentPersistentData::saveSavePath(%s)", qPrintable(save_path)); qDebug("TorrentPersistentData::saveSavePath(%s)", qPrintable(save_path));
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data.value(hash).toHash(); QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["save_path"] = save_path; data["save_path"] = save_path;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
qDebug("TorrentPersistentData: Saving save_path: %s, hash: %s", qPrintable(save_path), qPrintable(hash)); qDebug("TorrentPersistentData: Saving save_path: %s, hash: %s", qPrintable(save_path), qPrintable(hash));
} }
void TorrentPersistentData::saveLabel(const QString &hash, const QString &label) { void TorrentPersistentData::saveLabel(const QString &hash, const QString &label) {
Q_ASSERT(!hash.isEmpty()); Q_ASSERT(!hash.isEmpty());
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data.value(hash).toHash(); QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["label"] = label; data["label"] = label;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
} }
void TorrentPersistentData::saveName(const QString &hash, const QString &name) { void TorrentPersistentData::saveName(const QString &hash, const QString &name) {
Q_ASSERT(!hash.isEmpty()); Q_ASSERT(!hash.isEmpty());
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data.value(hash).toHash(); QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["name"] = name; data["name"] = name;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
} }
void TorrentPersistentData::savePriority(const QTorrentHandle &h) { void TorrentPersistentData::savePriority(const QTorrentHandle &h) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data[h.hash()].toHash(); QHash<QString, QVariant> data = all_data[h.hash()].toHash();
data["priority"] = h.queue_position(); data["priority"] = h.queue_position();
all_data[h.hash()] = data; all_data[h.hash()] = data;
settings.setValue("torrents", all_data); markDirty();
} }
void TorrentPersistentData::savePriority(const QString &hash, const int &queue_pos) { void TorrentPersistentData::savePriority(const QString &hash, const int &queue_pos) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data[hash].toHash(); QHash<QString, QVariant> data = all_data[hash].toHash();
data["priority"] = queue_pos; data["priority"] = queue_pos;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
} }
void TorrentPersistentData::saveSeedStatus(const QTorrentHandle &h) { void TorrentPersistentData::saveSeedStatus(const QTorrentHandle &h) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data[h.hash()].toHash(); QHash<QString, QVariant> data = all_data[h.hash()].toHash();
bool was_seed = data.value("seed", false).toBool(); bool was_seed = data.value("seed", false).toBool();
if (was_seed != h.is_seed()) { if (was_seed != h.is_seed()) {
data["seed"] = !was_seed; data["seed"] = !was_seed;
all_data[h.hash()] = data; all_data[h.hash()] = data;
settings.setValue("torrents", all_data); markDirty();
} }
} }
void TorrentPersistentData::saveSeedStatus(const QString &hash, const bool seedStatus) { void TorrentPersistentData::saveSeedStatus(const QString &hash, const bool seedStatus) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
QHash<QString, QVariant> data = all_data[hash].toHash(); QHash<QString, QVariant> data = all_data[hash].toHash();
data["seed"] = seedStatus; data["seed"] = seedStatus;
all_data[hash] = data; all_data[hash] = data;
settings.setValue("torrents", all_data); markDirty();
} }
QString TorrentPersistentData::getSavePath(const QString &hash) { QString TorrentPersistentData::getSavePath(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
//qDebug("TorrentPersistentData: getSavePath %s", data["save_path"].toString().toLocal8Bit().data()); //qDebug("TorrentPersistentData: getSavePath %s", data["save_path"].toString().toLocal8Bit().data());
return data.value("save_path").toString(); return data.value("save_path").toString();
} }
QString TorrentPersistentData::getLabel(const QString &hash) { QString TorrentPersistentData::getLabel(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("label", "").toString(); return data.value("label", "").toString();
} }
QString TorrentPersistentData::getName(const QString &hash) { QString TorrentPersistentData::getName(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("name", "").toString(); return data.value("name", "").toString();
} }
int TorrentPersistentData::getPriority(const QString &hash) { int TorrentPersistentData::getPriority(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("priority", -1).toInt(); return data.value("priority", -1).toInt();
} }
bool TorrentPersistentData::isSeed(const QString &hash) { bool TorrentPersistentData::isSeed(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("seed", false).toBool(); return data.value("seed", false).toBool();
} }
bool TorrentPersistentData::isMagnet(const QString &hash) { bool TorrentPersistentData::isMagnet(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("is_magnet", false).toBool(); return data.value("is_magnet", false).toBool();
} }
QString TorrentPersistentData::getMagnetUri(const QString &hash) { QString TorrentPersistentData::getMagnetUri(const QString &hash) {
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
Q_ASSERT(data.value("is_magnet", false).toBool()); Q_ASSERT(data.value("is_magnet", false).toBool());
return data.value("magnet_uri").toString(); return data.value("magnet_uri").toString();
} }
void TorrentPersistentData::markDirty() {
if (!dirty) {
dirty = true;
timer.start(1000);
}
}
void TorrentPersistentData::saveImpl() {
Q_ASSERT(dirty);
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
settings.setValue("torrents", all_data);
dirty = false;
timer.stop();
}

77
src/torrentpersistentdata.h
View File

@ -32,7 +32,9 @@
#define TORRENTPERSISTENTDATA_H #define TORRENTPERSISTENTDATA_H
#include <QHash> #include <QHash>
#include <QObject>
#include <QStringList> #include <QStringList>
#include <QTimer>
#include <vector> #include <vector>
#include "preferences.h" #include "preferences.h"
@ -112,7 +114,9 @@ private:
static unsigned int metadata_counter; static unsigned int metadata_counter;
}; };
class TorrentPersistentData { class TorrentPersistentData : QObject {
Q_OBJECT
Q_DISABLE_COPY(TorrentPersistentData)
// This class stores strings w/o modifying separators // This class stores strings w/o modifying separators
public: public:
enum RatioLimit { enum RatioLimit {
@ -121,36 +125,55 @@ public:
}; };
public: public:
static bool isKnownTorrent(QString hash); TorrentPersistentData();
static QStringList knownTorrents(); ~TorrentPersistentData();
static void setRatioLimit(const QString &hash, const qreal &ratio); void save();
static qreal getRatioLimit(const QString &hash);
static bool hasPerTorrentRatioLimit() ; public:
static void setAddedDate(const QString &hash, const QDateTime &time); static TorrentPersistentData& instance();
static QDateTime getAddedDate(const QString &hash);
static void setErrorState(const QString &hash, const bool has_error); bool isKnownTorrent(QString hash);
static bool hasError(const QString &hash); QStringList knownTorrents();
static QDateTime getSeedDate(const QString &hash); void setRatioLimit(const QString &hash, const qreal &ratio);
static void deletePersistentData(const QString &hash); qreal getRatioLimit(const QString &hash);
static void saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path = QString::null, const bool is_magnet = false); bool hasPerTorrentRatioLimit() ;
void setAddedDate(const QString &hash, const QDateTime &time);
QDateTime getAddedDate(const QString &hash);
void setErrorState(const QString &hash, const bool has_error);
bool hasError(const QString &hash);
QDateTime getSeedDate(const QString &hash);
void deletePersistentData(const QString &hash);
void saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path = QString::null, const bool is_magnet = false);
// Setters // Setters
static void saveSavePath(const QString &hash, const QString &save_path); void saveSavePath(const QString &hash, const QString &save_path);
static void saveLabel(const QString &hash, const QString &label); void saveLabel(const QString &hash, const QString &label);
static void saveName(const QString &hash, const QString &name); void saveName(const QString &hash, const QString &name);
static void savePriority(const QTorrentHandle &h); void savePriority(const QTorrentHandle &h);
static void savePriority(const QString &hash, const int &queue_pos); void savePriority(const QString &hash, const int &queue_pos);
static void saveSeedStatus(const QTorrentHandle &h); void saveSeedStatus(const QTorrentHandle &h);
static void saveSeedStatus(const QString &hash, const bool seedStatus); void saveSeedStatus(const QString &hash, const bool seedStatus);
// Getters // Getters
static QString getSavePath(const QString &hash); QString getSavePath(const QString &hash);
static QString getLabel(const QString &hash); QString getLabel(const QString &hash);
static QString getName(const QString &hash); QString getName(const QString &hash);
static int getPriority(const QString &hash); int getPriority(const QString &hash);
static bool isSeed(const QString &hash); bool isSeed(const QString &hash);
static bool isMagnet(const QString &hash); bool isMagnet(const QString &hash);
static QString getMagnetUri(const QString &hash); QString getMagnetUri(const QString &hash);
private:
void markDirty();
private slots:
void saveImpl();
private:
QHash<QString, QVariant> all_data;
bool dirty;
QTimer timer;
static TorrentPersistentData* m_instance;
}; };
#endif // TORRENTPERSISTENTDATA_H #endif // TORRENTPERSISTENTDATA_H

4
src/transferlistwidget.cpp
View File

@ -251,7 +251,7 @@ void TransferListWidget::setSelectedTorrentsLocation()
const QStringList hashes = getSelectedTorrentsHashes(); const QStringList hashes = getSelectedTorrentsHashes();
if (hashes.isEmpty()) return; if (hashes.isEmpty()) return;
QString dir; QString dir;
const QDir saveDir(TorrentPersistentData::getSavePath(hashes.first())); const QDir saveDir(TorrentPersistentData::instance().getSavePath(hashes.first()));
qDebug("Old save path is %s", qPrintable(saveDir.absolutePath())); qDebug("Old save path is %s", qPrintable(saveDir.absolutePath()));
dir = QFileDialog::getExistingDirectory(this, tr("Choose save path"), saveDir.absolutePath(), dir = QFileDialog::getExistingDirectory(this, tr("Choose save path"), saveDir.absolutePath(),
QFileDialog::DontConfirmOverwrite | QFileDialog::ShowDirsOnly | QFileDialog::HideNameFilterDetails); QFileDialog::DontConfirmOverwrite | QFileDialog::ShowDirsOnly | QFileDialog::HideNameFilterDetails);
@ -268,7 +268,7 @@ void TransferListWidget::setSelectedTorrentsLocation()
h.move_storage(savePath.absolutePath()); h.move_storage(savePath.absolutePath());
} }
else { else {
TorrentPersistentData::saveSavePath(h.hash(), savePath.absolutePath()); TorrentPersistentData::instance().saveSavePath(h.hash(), savePath.absolutePath());
main_window->getProperties()->updateSavePath(h); main_window->getProperties()->updateSavePath(h);
} }
} }

4
src/webui/btjson.cpp
View File

@ -415,7 +415,7 @@ QByteArray btjson::getPropertiesForTorrent(const QString& hash)
return QByteArray(); return QByteArray();
// Save path // Save path
QString save_path = fsutils::toNativePath(TorrentPersistentData::getSavePath(hash)); QString save_path = fsutils::toNativePath(TorrentPersistentData::instance().getSavePath(hash));
if (save_path.isEmpty()) if (save_path.isEmpty())
save_path = fsutils::toNativePath(h.save_path()); save_path = fsutils::toNativePath(h.save_path());
data[KEY_PROP_SAVE_PATH] = save_path; data[KEY_PROP_SAVE_PATH] = save_path;
@ -554,7 +554,7 @@ QVariantMap toMap(const QTorrentHandle& h)
ret[KEY_TORRENT_SEQUENTIAL_DOWNLOAD] = status.sequential_download; ret[KEY_TORRENT_SEQUENTIAL_DOWNLOAD] = status.sequential_download;
if (h.has_metadata()) if (h.has_metadata())
ret[KEY_TORRENT_FIRST_LAST_PIECE_PRIO] = h.first_last_piece_first(); ret[KEY_TORRENT_FIRST_LAST_PIECE_PRIO] = h.first_last_piece_first();
ret[KEY_TORRENT_LABEL] = TorrentPersistentData::getLabel(h.hash()); ret[KEY_TORRENT_LABEL] = TorrentPersistentData::instance().getLabel(h.hash());
return ret; return ret;
} }

2
src/webui/qtorrentfilter.cpp
View File

@ -116,5 +116,5 @@ bool QTorrentFilter::torrentHasLabel(const QTorrentHandle &h) const
if (label_.isNull()) if (label_.isNull())
return true; return true;
else else
return TorrentPersistentData::getLabel(h.hash()) == label_; return TorrentPersistentData::instance().getLabel(h.hash()) == label_;
} }