d4708
/
qBittorrent
mirror of https://github.com/d47081/qBittorrent.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Improve torrent initialization 

Don't post "torrent resumed" event when torrent starts in "resumed"
state.
Fix confusing names. Now "resumed torrent" means "unpaused torrent"
only. When we load previously added torrent it is called "restored
torrent".
adaptive-webui-19844
Vladimir Golovnev (Glassez) 6 years ago
parent
7ebd63a60f
commit
cd44ab2fc6
No known key found for this signature in database
GPG Key ID: 52A2C7DEE2DFA6F7
4 changed files with 109 additions and 98 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 113
      src/base/bittorrent/session.cpp
  2. 6
      src/base/bittorrent/session.h
  3. 66
      src/base/bittorrent/torrenthandle.cpp
  4. 20
      src/base/bittorrent/torrenthandle.h

113
src/base/bittorrent/session.cpp
Unescape View File

@ -111,7 +111,7 @@ using namespace BitTorrent;
namespace namespace
{ {
bool readFile(const QString &path, QByteArray &buf); bool readFile(const QString &path, QByteArray &buf);
bool loadTorrentResumeData(const QByteArray &data, AddTorrentData &torrentData, int &prio, MagnetUri &magnetUri); bool loadTorrentResumeData(const QByteArray &data, CreateTorrentParams &torrentParams, int &prio, MagnetUri &magnetUri);
void torrentQueuePositionUp(const libt::torrent_handle &handle); void torrentQueuePositionUp(const libt::torrent_handle &handle);
void torrentQueuePositionDown(const libt::torrent_handle &handle); void torrentQueuePositionDown(const libt::torrent_handle &handle);
@ -2110,15 +2110,15 @@ bool Session::addTorrent(const TorrentInfo &torrentInfo, const AddTorrentParams
} }
// Add a torrent to the BitTorrent session // Add a torrent to the BitTorrent session
bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri, bool Session::addTorrent_impl(CreateTorrentParams params, const MagnetUri &magnetUri,
TorrentInfo torrentInfo, const QByteArray &fastresumeData) TorrentInfo torrentInfo, const QByteArray &fastresumeData)
{ {
addData.savePath = normalizeSavePath(addData.savePath, ""); params.savePath = normalizeSavePath(params.savePath, "");
if (!addData.category.isEmpty()) { if (!params.category.isEmpty()) {
if (!m_categories.contains(addData.category) && !addCategory(addData.category)) { if (!m_categories.contains(params.category) && !addCategory(params.category)) {
qWarning() << "Couldn't create category" << addData.category; qWarning() << "Couldn't create category" << params.category;
addData.category = ""; params.category = "";
} }
} }
@ -2127,10 +2127,10 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
std::vector<boost::uint8_t> filePriorities; std::vector<boost::uint8_t> filePriorities;
QString savePath; QString savePath;
if (addData.savePath.isEmpty()) // using Automatic mode if (params.savePath.isEmpty()) // using Automatic mode
savePath = categorySavePath(addData.category); savePath = categorySavePath(params.category);
else // using Manual mode else // using Manual mode
savePath = addData.savePath; savePath = params.savePath;
bool fromMagnetUri = magnetUri.isValid(); bool fromMagnetUri = magnetUri.isValid();
if (fromMagnetUri) { if (fromMagnetUri) {
@ -2151,7 +2151,7 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
adjustLimits(); adjustLimits();
// use common 2nd step of torrent addition // use common 2nd step of torrent addition
m_addingTorrents.insert(hash, addData); m_addingTorrents.insert(hash, params);
createTorrentHandle(handle); createTorrentHandle(handle);
return true; return true;
} }
@ -2159,23 +2159,23 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
p = magnetUri.addTorrentParams(); p = magnetUri.addTorrentParams();
} }
else if (torrentInfo.isValid()) { else if (torrentInfo.isValid()) {
if (!addData.resumed) { if (!params.restored) {
if (!addData.hasRootFolder) if (!params.hasRootFolder)
torrentInfo.stripRootFolder(); torrentInfo.stripRootFolder();
// Metadata // Metadata
if (!addData.hasSeedStatus) if (!params.hasSeedStatus)
findIncompleteFiles(torrentInfo, savePath); findIncompleteFiles(torrentInfo, savePath);
// if torrent name wasn't explicitly set we handle the case of // if torrent name wasn't explicitly set we handle the case of
// initial renaming of torrent content and rename torrent accordingly // initial renaming of torrent content and rename torrent accordingly
if (addData.name.isEmpty()) { if (params.name.isEmpty()) {
QString contentName = torrentInfo.rootFolder(); QString contentName = torrentInfo.rootFolder();
if (contentName.isEmpty() && (torrentInfo.filesCount() == 1)) if (contentName.isEmpty() && (torrentInfo.filesCount() == 1))
contentName = torrentInfo.fileName(0); contentName = torrentInfo.fileName(0);
if (!contentName.isEmpty() && (contentName != torrentInfo.name())) if (!contentName.isEmpty() && (contentName != torrentInfo.name()))
addData.name = contentName; params.name = contentName;
} }
} }
@ -2189,13 +2189,13 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
return false; return false;
} }
if (addData.resumed && !fromMagnetUri) { if (params.restored && !fromMagnetUri) {
// Set torrent fast resume data // Set torrent fast resume data
p.resume_data = {fastresumeData.constData(), fastresumeData.constData() + fastresumeData.size()}; p.resume_data = {fastresumeData.constData(), fastresumeData.constData() + fastresumeData.size()};
p.flags |= libt::add_torrent_params::flag_use_resume_save_path; p.flags |= libt::add_torrent_params::flag_use_resume_save_path;
} }
else { else {
foreach (int prio, addData.filePriorities) foreach (int prio, params.filePriorities)
filePriorities.push_back(prio); filePriorities.push_back(prio);
p.file_priorities = filePriorities; p.file_priorities = filePriorities;
} }
@ -2228,7 +2228,7 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
// Seeding mode // Seeding mode
// Skip checking and directly start seeding (new in libtorrent v0.15) // Skip checking and directly start seeding (new in libtorrent v0.15)
if (addData.skipChecking) if (params.skipChecking)
p.flags |= libt::add_torrent_params::flag_seed_mode; p.flags |= libt::add_torrent_params::flag_seed_mode;
else else
p.flags &= ~libt::add_torrent_params::flag_seed_mode; p.flags &= ~libt::add_torrent_params::flag_seed_mode;
@ -2237,10 +2237,10 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
p.max_connections = maxConnectionsPerTorrent(); p.max_connections = maxConnectionsPerTorrent();
p.max_uploads = maxUploadsPerTorrent(); p.max_uploads = maxUploadsPerTorrent();
p.save_path = Utils::Fs::toNativePath(savePath).toStdString(); p.save_path = Utils::Fs::toNativePath(savePath).toStdString();
p.upload_limit = addData.uploadLimit; p.upload_limit = params.uploadLimit;
p.download_limit = addData.downloadLimit; p.download_limit = params.downloadLimit;
m_addingTorrents.insert(hash, addData); m_addingTorrents.insert(hash, params);
// Adding torrent to BitTorrent session // Adding torrent to BitTorrent session
m_nativeSession->async_add_torrent(p); m_nativeSession->async_add_torrent(p);
return true; return true;
@ -3849,7 +3849,7 @@ void Session::startUpTorrents()
{ {
QString hash; QString hash;
MagnetUri magnetUri; MagnetUri magnetUri;
AddTorrentData addTorrentData; CreateTorrentParams addTorrentData;
QByteArray data; QByteArray data;
} TorrentResumeData; } TorrentResumeData;
@ -3882,12 +3882,12 @@ void Session::startUpTorrents()
QString hash = rxMatch.captured(1); QString hash = rxMatch.captured(1);
QString fastresumePath = resumeDataDir.absoluteFilePath(fastresumeName); QString fastresumePath = resumeDataDir.absoluteFilePath(fastresumeName);
QByteArray data; QByteArray data;
AddTorrentData resumeData; CreateTorrentParams torrentParams;
MagnetUri magnetUri; MagnetUri magnetUri;
int queuePosition; int queuePosition;
if (readFile(fastresumePath, data) && loadTorrentResumeData(data, resumeData, queuePosition, magnetUri)) { if (readFile(fastresumePath, data) && loadTorrentResumeData(data, torrentParams, queuePosition, magnetUri)) {
if (queuePosition <= nextQueuePosition) { if (queuePosition <= nextQueuePosition) {
startupTorrent({ hash, magnetUri, resumeData, data }); startupTorrent({ hash, magnetUri, torrentParams, data });
if (queuePosition == nextQueuePosition) { if (queuePosition == nextQueuePosition) {
++nextQueuePosition; ++nextQueuePosition;
@ -3904,7 +3904,7 @@ void Session::startUpTorrents()
if (q != queuePosition) { if (q != queuePosition) {
++numOfRemappedFiles; ++numOfRemappedFiles;
} }
queuedResumeData[q] = {hash, magnetUri, resumeData, data}; queuedResumeData[q] = {hash, magnetUri, torrentParams, data};
} }
} }
} }
@ -4108,25 +4108,19 @@ void Session::createTorrentHandle(const libt::torrent_handle &nativeHandle)
// Magnet added for preload its metadata // Magnet added for preload its metadata
if (!m_addingTorrents.contains(nativeHandle.info_hash())) return; if (!m_addingTorrents.contains(nativeHandle.info_hash())) return;
AddTorrentData data = m_addingTorrents.take(nativeHandle.info_hash()); CreateTorrentParams params = m_addingTorrents.take(nativeHandle.info_hash());
TorrentHandle *const torrent = new TorrentHandle(this, nativeHandle, data); TorrentHandle *const torrent = new TorrentHandle(this, nativeHandle, params);
m_torrents.insert(torrent->hash(), torrent); m_torrents.insert(torrent->hash(), torrent);
Logger *const logger = Logger::instance(); Logger *const logger = Logger::instance();
bool fromMagnetUri = !torrent->hasMetadata(); bool fromMagnetUri = !torrent->hasMetadata();
if (data.resumed) { if (params.restored) {
if (fromMagnetUri && !data.addPaused) logger->addMessage(tr("'%1' restored.", "'torrent name' restored.").arg(torrent->name()));
torrent->resume(data.addForced);
logger->addMessage(tr("'%1' resumed. (fast resume)", "'torrent name' was resumed. (fast resume)")
.arg(torrent->name()));
} }
else { else {
qDebug("This is a NEW torrent (first time)...");
// The following is useless for newly added magnet // The following is useless for newly added magnet
if (!fromMagnetUri) { if (!fromMagnetUri) {
// Backup torrent file // Backup torrent file
@ -4145,9 +4139,6 @@ void Session::createTorrentHandle(const libt::torrent_handle &nativeHandle)
if (isAddTrackersEnabled() && !torrent->isPrivate()) if (isAddTrackersEnabled() && !torrent->isPrivate())
torrent->addTrackers(m_additionalTrackerList); torrent->addTrackers(m_additionalTrackerList);
// Start torrent because it was added in paused state
if (!data.addPaused)
torrent->resume();
logger->addMessage(tr("'%1' added to download list.", "'torrent name' was added to download list.") logger->addMessage(tr("'%1' added to download list.", "'torrent name' was added to download list.")
.arg(torrent->name())); .arg(torrent->name()));
@ -4163,7 +4154,7 @@ void Session::createTorrentHandle(const libt::torrent_handle &nativeHandle)
// Send torrent addition signal // Send torrent addition signal
emit torrentAdded(torrent); emit torrentAdded(torrent);
// Send new torrent signal // Send new torrent signal
if (!data.resumed) if (!params.restored)
emit torrentNew(torrent); emit torrentNew(torrent);
} }
@ -4513,11 +4504,11 @@ namespace
return true; return true;
} }
bool loadTorrentResumeData(const QByteArray &data, AddTorrentData &torrentData, int &prio, MagnetUri &magnetUri) bool loadTorrentResumeData(const QByteArray &data, CreateTorrentParams &torrentParams, int &prio, MagnetUri &magnetUri)
{ {
torrentData = AddTorrentData(); torrentParams = CreateTorrentParams();
torrentData.resumed = true; torrentParams.restored = true;
torrentData.skipChecking = false; torrentParams.skipChecking = false;
libt::error_code ec; libt::error_code ec;
#if LIBTORRENT_VERSION_NUM < 10100 #if LIBTORRENT_VERSION_NUM < 10100
@ -4530,36 +4521,36 @@ namespace
if (ec || (fast.type() != libt::bdecode_node::dict_t)) return false; if (ec || (fast.type() != libt::bdecode_node::dict_t)) return false;
#endif #endif
torrentData.savePath = Profile::instance().fromPortablePath( torrentParams.savePath = Profile::instance().fromPortablePath(
Utils::Fs::fromNativePath(QString::fromStdString(fast.dict_find_string_value("qBt-savePath")))); Utils::Fs::fromNativePath(QString::fromStdString(fast.dict_find_string_value("qBt-savePath"))));
std::string ratioLimitString = fast.dict_find_string_value("qBt-ratioLimit"); std::string ratioLimitString = fast.dict_find_string_value("qBt-ratioLimit");
if (ratioLimitString.empty()) if (ratioLimitString.empty())
torrentData.ratioLimit = fast.dict_find_int_value("qBt-ratioLimit", TorrentHandle::USE_GLOBAL_RATIO * 1000) / 1000.0; torrentParams.ratioLimit = fast.dict_find_int_value("qBt-ratioLimit", TorrentHandle::USE_GLOBAL_RATIO * 1000) / 1000.0;
else else
torrentData.ratioLimit = QString::fromStdString(ratioLimitString).toDouble(); torrentParams.ratioLimit = QString::fromStdString(ratioLimitString).toDouble();
torrentData.seedingTimeLimit = fast.dict_find_int_value("qBt-seedingTimeLimit", TorrentHandle::USE_GLOBAL_SEEDING_TIME); torrentParams.seedingTimeLimit = fast.dict_find_int_value("qBt-seedingTimeLimit", TorrentHandle::USE_GLOBAL_SEEDING_TIME);
// ************************************************************************************** // **************************************************************************************
// Workaround to convert legacy label to category // Workaround to convert legacy label to category
// TODO: Should be removed in future // TODO: Should be removed in future
torrentData.category = QString::fromStdString(fast.dict_find_string_value("qBt-label")); torrentParams.category = QString::fromStdString(fast.dict_find_string_value("qBt-label"));
if (torrentData.category.isEmpty()) if (torrentParams.category.isEmpty())
// ************************************************************************************** // **************************************************************************************
torrentData.category = QString::fromStdString(fast.dict_find_string_value("qBt-category")); torrentParams.category = QString::fromStdString(fast.dict_find_string_value("qBt-category"));
// auto because the return type depends on the #if above. // auto because the return type depends on the #if above.
const auto tagsEntry = fast.dict_find_list("qBt-tags"); const auto tagsEntry = fast.dict_find_list("qBt-tags");
if (isList(tagsEntry)) if (isList(tagsEntry))
torrentData.tags = entryListToSet(tagsEntry); torrentParams.tags = entryListToSet(tagsEntry);
torrentData.name = QString::fromStdString(fast.dict_find_string_value("qBt-name")); torrentParams.name = QString::fromStdString(fast.dict_find_string_value("qBt-name"));
torrentData.hasSeedStatus = fast.dict_find_int_value("qBt-seedStatus"); torrentParams.hasSeedStatus = fast.dict_find_int_value("qBt-seedStatus");
torrentData.disableTempPath = fast.dict_find_int_value("qBt-tempPathDisabled"); torrentParams.disableTempPath = fast.dict_find_int_value("qBt-tempPathDisabled");
torrentData.hasRootFolder = fast.dict_find_int_value("qBt-hasRootFolder"); torrentParams.hasRootFolder = fast.dict_find_int_value("qBt-hasRootFolder");
magnetUri = MagnetUri(QString::fromStdString(fast.dict_find_string_value("qBt-magnetUri"))); magnetUri = MagnetUri(QString::fromStdString(fast.dict_find_string_value("qBt-magnetUri")));
torrentData.addPaused = fast.dict_find_int_value("qBt-paused"); torrentParams.paused = fast.dict_find_int_value("qBt-paused");
torrentData.addForced = fast.dict_find_int_value("qBt-forced"); torrentParams.forced = fast.dict_find_int_value("qBt-forced");
torrentData.firstLastPiecePriority = fast.dict_find_int_value("qBt-firstLastPiecePriority"); torrentParams.firstLastPiecePriority = fast.dict_find_int_value("qBt-firstLastPiecePriority");
torrentData.sequential = fast.dict_find_int_value("qBt-sequential"); torrentParams.sequential = fast.dict_find_int_value("qBt-sequential");
prio = fast.dict_find_int_value("qBt-queuePosition"); prio = fast.dict_find_int_value("qBt-queuePosition");

6
src/base/bittorrent/session.h
Unescape View File

@ -138,7 +138,7 @@ namespace BitTorrent
class Tracker; class Tracker;
class MagnetUri; class MagnetUri;
class TrackerEntry; class TrackerEntry;
struct AddTorrentData; struct CreateTorrentParams;
struct TorrentStatusReport struct TorrentStatusReport
{ {
@ -598,7 +598,7 @@ namespace BitTorrent
void enableIPFilter(); void enableIPFilter();
void disableIPFilter(); void disableIPFilter();
bool addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri, bool addTorrent_impl(CreateTorrentParams params, const MagnetUri &magnetUri,
TorrentInfo torrentInfo = TorrentInfo(), TorrentInfo torrentInfo = TorrentInfo(),
const QByteArray &fastresumeData = QByteArray()); const QByteArray &fastresumeData = QByteArray());
bool findIncompleteFiles(TorrentInfo &torrentInfo, QString &savePath) const; bool findIncompleteFiles(TorrentInfo &torrentInfo, QString &savePath) const;
@ -758,7 +758,7 @@ namespace BitTorrent
QHash<InfoHash, TorrentInfo> m_loadedMetadata; QHash<InfoHash, TorrentInfo> m_loadedMetadata;
QHash<InfoHash, TorrentHandle *> m_torrents; QHash<InfoHash, TorrentHandle *> m_torrents;
QHash<InfoHash, AddTorrentData> m_addingTorrents; QHash<InfoHash, CreateTorrentParams> m_addingTorrents;
QHash<QString, AddTorrentParams> m_downloadedTorrents; QHash<QString, AddTorrentParams> m_downloadedTorrents;
QHash<InfoHash, RemovingTorrentData> m_removingTorrents; QHash<InfoHash, RemovingTorrentData> m_removingTorrents;
TorrentStatusReport m_torrentStatusReport; TorrentStatusReport m_torrentStatusReport;

66
src/base/bittorrent/torrenthandle.cpp
Unescape View File

@ -85,16 +85,16 @@ namespace
// AddTorrentData // AddTorrentData
AddTorrentData::AddTorrentData() CreateTorrentParams::CreateTorrentParams()
: resumed(false) : restored(false)
, disableTempPath(false) , disableTempPath(false)
, sequential(false) , sequential(false)
, firstLastPiecePriority(false) , firstLastPiecePriority(false)
, hasSeedStatus(false) , hasSeedStatus(false)
, skipChecking(false) , skipChecking(false)
, hasRootFolder(true) , hasRootFolder(true)
, addForced(false) , forced(false)
, addPaused(false) , paused(false)
, uploadLimit(-1) , uploadLimit(-1)
, downloadLimit(-1) , downloadLimit(-1)
, ratioLimit(TorrentHandle::USE_GLOBAL_RATIO) , ratioLimit(TorrentHandle::USE_GLOBAL_RATIO)
@ -102,8 +102,8 @@ AddTorrentData::AddTorrentData()
{ {
} }
AddTorrentData::AddTorrentData(const AddTorrentParams &params) CreateTorrentParams::CreateTorrentParams(const AddTorrentParams &params)
: resumed(false) : restored(false)
, name(params.name) , name(params.name)
, category(params.category) , category(params.category)
, tags(params.tags) , tags(params.tags)
@ -116,8 +116,8 @@ AddTorrentData::AddTorrentData(const AddTorrentParams &params)
, hasRootFolder(params.createSubfolder == TriStateBool::Undefined , hasRootFolder(params.createSubfolder == TriStateBool::Undefined
? Session::instance()->isCreateTorrentSubfolder() ? Session::instance()->isCreateTorrentSubfolder()
: params.createSubfolder == TriStateBool::True) : params.createSubfolder == TriStateBool::True)
, addForced(params.addForced == TriStateBool::True) , forced(params.addForced == TriStateBool::True)
, addPaused(params.addPaused == TriStateBool::Undefined , paused(params.addPaused == TriStateBool::Undefined
? Session::instance()->isAddTorrentPaused() ? Session::instance()->isAddTorrentPaused()
: params.addPaused == TriStateBool::True) : params.addPaused == TriStateBool::True)
, uploadLimit(params.uploadLimit) , uploadLimit(params.uploadLimit)
@ -172,23 +172,23 @@ namespace
} }
TorrentHandle::TorrentHandle(Session *session, const libtorrent::torrent_handle &nativeHandle, TorrentHandle::TorrentHandle(Session *session, const libtorrent::torrent_handle &nativeHandle,
const AddTorrentData &data) const CreateTorrentParams &params)
: QObject(session) : QObject(session)
, m_session(session) , m_session(session)
, m_nativeHandle(nativeHandle) , m_nativeHandle(nativeHandle)
, m_state(TorrentState::Unknown) , m_state(TorrentState::Unknown)
, m_renameCount(0) , m_renameCount(0)
, m_useAutoTMM(data.savePath.isEmpty()) , m_useAutoTMM(params.savePath.isEmpty())
, m_name(data.name) , m_name(params.name)
, m_savePath(Utils::Fs::toNativePath(data.savePath)) , m_savePath(Utils::Fs::toNativePath(params.savePath))
, m_category(data.category) , m_category(params.category)
, m_tags(data.tags) , m_tags(params.tags)
, m_hasSeedStatus(data.hasSeedStatus) , m_hasSeedStatus(params.hasSeedStatus)
, m_ratioLimit(data.ratioLimit) , m_ratioLimit(params.ratioLimit)
, m_seedingTimeLimit(data.seedingTimeLimit) , m_seedingTimeLimit(params.seedingTimeLimit)
, m_tempPathDisabled(data.disableTempPath) , m_tempPathDisabled(params.disableTempPath)
, m_hasMissingFiles(false) , m_hasMissingFiles(false)
, m_hasRootFolder(data.hasRootFolder) , m_hasRootFolder(params.hasRootFolder)
, m_needsToSetFirstLastPiecePriority(false) , m_needsToSetFirstLastPiecePriority(false)
, m_pauseAfterRecheck(false) , m_pauseAfterRecheck(false)
{ {
@ -206,15 +206,29 @@ TorrentHandle::TorrentHandle(Session *session, const libtorrent::torrent_handle
// download sequentially or have first/last piece priority enabled when // download sequentially or have first/last piece priority enabled when
// its resume data was saved. These two settings are restored later. But // its resume data was saved. These two settings are restored later. But
// if we set them to false now, both will erroneously not be restored. // if we set them to false now, both will erroneously not be restored.
if (!data.resumed || data.sequential) if (!params.restored || params.sequential)
setSequentialDownload(data.sequential); setSequentialDownload(params.sequential);
if (!data.resumed || data.firstLastPiecePriority) if (!params.restored || params.firstLastPiecePriority)
setFirstLastPiecePriority(data.firstLastPiecePriority); setFirstLastPiecePriority(params.firstLastPiecePriority);
if (!data.resumed && hasMetadata()) { if (!params.restored && hasMetadata()) {
if (filesCount() == 1) if (filesCount() == 1)
m_hasRootFolder = false; m_hasRootFolder = false;
} }
// "started" means "all initialization has completed and torrent has started regular processing".
// When torrent added/restored in "paused" state it become "started" immediately after construction.
// When it is added/restored in "resumed" state, it become "started" after it is really resumed
// (i.e. after receiving "torrent resumed" alert).
m_started = (params.restored && hasMetadata() ? isPaused() : params.paused);
if (!m_started) {
if (!params.restored || !hasMetadata()) {
// Resume torrent because it was added in "resumed" state
// but it's actually paused during initialization
resume(params.forced);
}
}
} }
TorrentHandle::~TorrentHandle() {} TorrentHandle::~TorrentHandle() {}
@ -1589,7 +1603,11 @@ void TorrentHandle::handleTorrentPausedAlert(const libtorrent::torrent_paused_al
void TorrentHandle::handleTorrentResumedAlert(const libtorrent::torrent_resumed_alert *p) void TorrentHandle::handleTorrentResumedAlert(const libtorrent::torrent_resumed_alert *p)
{ {
Q_UNUSED(p); Q_UNUSED(p);
if (m_started)
m_session->handleTorrentResumed(this); m_session->handleTorrentResumed(this);
else
m_started = true;
} }
void TorrentHandle::handleSaveResumeDataAlert(const libtorrent::save_resume_data_alert *p) void TorrentHandle::handleSaveResumeDataAlert(const libtorrent::save_resume_data_alert *p)

20
src/base/bittorrent/torrenthandle.h
Unescape View File

@ -88,10 +88,10 @@ namespace BitTorrent
class TrackerEntry; class TrackerEntry;
struct AddTorrentParams; struct AddTorrentParams;
struct AddTorrentData struct CreateTorrentParams
{ {
bool resumed; bool restored; // is existing torrent job?
// for both new and resumed torrents // for both new and restored torrents
QString name; QString name;
QString category; QString category;
QSet<QString> tags; QSet<QString> tags;
@ -102,18 +102,18 @@ namespace BitTorrent
bool hasSeedStatus; bool hasSeedStatus;
bool skipChecking; bool skipChecking;
bool hasRootFolder; bool hasRootFolder;
bool addForced; bool forced;
bool addPaused; bool paused;
int uploadLimit; int uploadLimit;
int downloadLimit; int downloadLimit;
// for new torrents // for new torrents
QVector<int> filePriorities; QVector<int> filePriorities;
// for resumed torrents // for restored torrents
qreal ratioLimit; qreal ratioLimit;
int seedingTimeLimit; int seedingTimeLimit;
AddTorrentData(); CreateTorrentParams();
AddTorrentData(const AddTorrentParams &params); CreateTorrentParams(const AddTorrentParams &params);
}; };
struct TrackerInfo struct TrackerInfo
@ -170,7 +170,7 @@ namespace BitTorrent
static const int MAX_SEEDING_TIME; static const int MAX_SEEDING_TIME;
TorrentHandle(Session *session, const libtorrent::torrent_handle &nativeHandle, TorrentHandle(Session *session, const libtorrent::torrent_handle &nativeHandle,
const AddTorrentData &data); const CreateTorrentParams &params);
~TorrentHandle(); ~TorrentHandle();
bool isValid() const; bool isValid() const;
@ -462,6 +462,8 @@ namespace BitTorrent
bool m_pauseAfterRecheck; bool m_pauseAfterRecheck;
QHash<QString, TrackerInfo> m_trackerInfos; QHash<QString, TrackerInfo> m_trackerInfos;
bool m_started = false;
}; };
} }

Write Preview
Loading…
Cancel
Save