998 lines
29 KiB
C++
998 lines
29 KiB
C++
#ifndef DOWNLOAD_H
|
|
#define DOWNLOAD_H
|
|
|
|
#include "./downloadrange.h"
|
|
#include "./optiondata.h"
|
|
|
|
#include <c++utilities/chrono/timespan.h>
|
|
|
|
#include <QAuthenticator>
|
|
#include <QBuffer>
|
|
#include <QFile>
|
|
#include <QNetworkProxy>
|
|
#include <QNetworkReply>
|
|
#include <QObject>
|
|
#include <QTime>
|
|
|
|
#include <tuple>
|
|
|
|
namespace Network {
|
|
|
|
/*!
|
|
* \brief Specifies the download status.
|
|
*/
|
|
enum class DownloadStatus {
|
|
None, /**< The download has just been created. Call init() to initialize the download. */
|
|
Initiating, /**< The download is currently initiating after init() has been called. */
|
|
Waiting, /**< The download is currently waiting for a permission or the output device to be set. */
|
|
Ready, /**< The download is initiated. It may be started using the start() method. */
|
|
Downloading, /**< The download is actually downloading. */
|
|
FinishOuputFile, /**< The download is not downloading anymore but still writing data from the buffer to the output file. */
|
|
Interrupting, /**< The is being interrupted after interrupt() has been called. */
|
|
Aborting, /**< The is being aborted after abort() has been called. */
|
|
Interrupted, /**< The download is interrupted after interrupt() has been called. */
|
|
Failed, /**< The download failed. The download might enter this status after the initialization has failed or the actual download has failed or has been aborted. */
|
|
Finished /**< The download has been finished and all received data has been written to the output file. */
|
|
};
|
|
|
|
class Download : public QObject {
|
|
Q_OBJECT
|
|
public:
|
|
virtual ~Download();
|
|
|
|
public slots:
|
|
// public slots to control the download
|
|
void init();
|
|
void start();
|
|
void start(const QString &targetPath);
|
|
void start(QIODevice *targetDevice, bool giveOwnership = false);
|
|
void stop();
|
|
void interrupt();
|
|
|
|
public:
|
|
// public methods
|
|
// to get status information
|
|
bool canStart(QString &reasonIfNot);
|
|
DownloadStatus status() const;
|
|
DownloadStatus lastStatus() const;
|
|
int progressPercentage() const;
|
|
double speed() const;
|
|
double shiftSpeed();
|
|
CppUtilities::TimeSpan remainingTime() const;
|
|
CppUtilities::TimeSpan shiftRemainingTime();
|
|
qint64 bytesReceived() const;
|
|
qint64 newBytesReceived();
|
|
qint64 bytesToReceive() const;
|
|
qint64 newBytesToReceive();
|
|
int lastProgressUpdate() const;
|
|
bool hasStatusInfo() const;
|
|
const QString &statusInfo() const;
|
|
QNetworkReply::NetworkError networkError() const;
|
|
bool isStarted() const;
|
|
bool isWorking() const;
|
|
bool isDownloading() const;
|
|
bool isInitiated() const;
|
|
|
|
// to get and set meta data and additional information
|
|
const QString &targetPath() const;
|
|
void setTargetPath(const QString &targetPath);
|
|
const QUrl &initialUrl() const;
|
|
const QUrl &downloadUrl() const;
|
|
const QUrl &downloadUrl(size_t optionIndex) const;
|
|
const std::vector<OptionData> &options() const;
|
|
std::vector<OptionData> &options();
|
|
const QString &id() const;
|
|
const QString &title() const;
|
|
const QString &collectionName() const;
|
|
size_t availableOptionCount() const;
|
|
bool areOptionsAvailable() const;
|
|
const QString &optionName(size_t optionIndex) const;
|
|
bool haveAvailableOptionsChanged();
|
|
bool isValidOptionChosen() const;
|
|
size_t chosenOption() const;
|
|
const QString &chosenOptionName() const;
|
|
bool setChosenOption(size_t optionIndex);
|
|
bool hasSelectedOptionChanged();
|
|
const QString &userAgent();
|
|
void setCustomUserAgent(const QString &value);
|
|
bool isDefaultUserAgentUsed() const;
|
|
void setDefaultUserAgentUsed(bool defaultUserAgentUsed);
|
|
static const QString &defaultUserAgent();
|
|
static void scrambleDefaultUserAgent();
|
|
const QNetworkProxy &proxy() const;
|
|
void setProxy(const QNetworkProxy &value);
|
|
const QString &uploader() const;
|
|
int views() const;
|
|
CppUtilities::TimeSpan duration() const;
|
|
const QString &rating() const;
|
|
int positionInCollection() const;
|
|
int progressUpdateInterval() const;
|
|
void setProgressUpdateInterval(int value);
|
|
virtual QString suitableFilename() const;
|
|
DownloadRange &range();
|
|
bool setRange(const DownloadRange &value);
|
|
virtual bool supportsRange() const;
|
|
virtual QString typeName() const = 0;
|
|
void provideMetaData(const QString &title = QString(), const QString &uploader = QString(),
|
|
CppUtilities::TimeSpan duration = CppUtilities::TimeSpan(), const QString &collectionName = QString(), int positionInCollection = 0,
|
|
int views = 0, const QString &rating = QString());
|
|
void setOverwritePermission(size_t optionIndex, PermissionStatus permission);
|
|
void setAppendPermission(size_t optionIndex, PermissionStatus permission);
|
|
void setRedirectPermission(size_t originalOptionIndex, PermissionStatus permission);
|
|
void setIgnoreSslErrorsPermission(size_t optionIndex, PermissionStatus permission);
|
|
void provideOutputDevice(size_t optionIndex, QIODevice *device, bool giveOwnership = false);
|
|
void provideAuthenticationCredentials(size_t optionIndex, const AuthenticationCredentials &credentials);
|
|
const AuthenticationCredentials &initialAuthenticationCredentials() const;
|
|
AuthenticationCredentials &initialAuthenticationCredentials();
|
|
virtual bool isInitiatingInstantlyRecommendable() const;
|
|
|
|
// to construct new downloads
|
|
static Download *fromUrl(const QUrl &url);
|
|
|
|
signals:
|
|
void statusChanged(Download *download);
|
|
void progressChanged(Download *download);
|
|
void statusInfoChanged(Download *download);
|
|
void overwriteingPermissionRequired(Download *download, size_t optionIndex, const QString &file);
|
|
void appendingPermissionRequired(Download *download, size_t optionIndex, const QString &file, quint64 offset, quint64 fileSize);
|
|
void redirectionPermissonRequired(Download *download, size_t optionIndex, int redirectionOptionIndex);
|
|
void outputDeviceRequired(Download *concerningDownload, size_t optionIndex);
|
|
void authenticationRequired(Download *concerningDownload, size_t optionIndex, const QString &statusInfo);
|
|
void sslErrors(Download *concerningDownload, size_t optionIndex, const QList<QSslError> &sslErrors);
|
|
|
|
protected:
|
|
// c'tor
|
|
explicit Download(const QUrl &url = QUrl(), QObject *parent = nullptr);
|
|
|
|
// protected methods
|
|
// to be implemented by derived classes
|
|
virtual void doDownload() = 0;
|
|
virtual bool followRedirection(size_t originalOptionIndex);
|
|
virtual void abortDownload() = 0;
|
|
virtual void doInit() = 0;
|
|
virtual void checkStatusAndClear(size_t optionIndex) = 0;
|
|
// meant to be called by derived classes
|
|
size_t addDownloadUrl(const QString &optionName, const QUrl &url, size_t redirectionOf = InvalidOptionIndex);
|
|
void changeDownloadUrl(size_t optionIndex, const QUrl &value);
|
|
void reportInitiated(
|
|
bool success, const QString &reasonIfNot = QString(), const QNetworkReply::NetworkError &networkError = QNetworkReply::NoError);
|
|
void reportFinalDownloadStatus(size_t optionIndex, bool success, const QString &statusDescription = QString(),
|
|
QNetworkReply::NetworkError networkError = QNetworkReply::NoError);
|
|
protected slots:
|
|
void reportDownloadInterrupted(size_t optionIndex);
|
|
void reportNewDataToBeWritten(size_t optionIndex, QIODevice *inputDevice);
|
|
void reportRedirectionAvailable(size_t originalOptionIndex);
|
|
void reportAuthenticationRequired(size_t optionIndex, const QString &realm);
|
|
void reportSslErrors(size_t optionIndex, QNetworkReply *reply, const QList<QSslError> &sslErrors);
|
|
void reportDownloadComplete(size_t optionIndex);
|
|
void finalizeOutputDevice(size_t optionIndex);
|
|
void setId(const QString &value);
|
|
void setTitle(const QString &value);
|
|
void setTitleFromFilename(const QString &valueObtainedFromFilename);
|
|
void setUploader(const QString &value);
|
|
void setViews(int value);
|
|
void setDuration(CppUtilities::TimeSpan value);
|
|
void setRating(const QString &value);
|
|
void setPositionInCollection(int value);
|
|
void setCollectionName(const QString &value);
|
|
void reportDownloadProgressUpdate(size_t optionIndex, qint64 bytesReceived, qint64 bytesToReceive);
|
|
|
|
private:
|
|
// private static methods
|
|
static const QUrl &emptyUrl();
|
|
static const QString &emptyString();
|
|
|
|
// private methods
|
|
// to handle the output device
|
|
bool writeBufferToOutputDevice(size_t optionIndex);
|
|
bool prepareOutputDevice(size_t optionIndex, QIODevice *device, bool takeOwnership);
|
|
void ensureOutputDeviceIsPrepared(size_t optionIndex);
|
|
// to set status information
|
|
void setBytesWritten(qint64 value);
|
|
void setProgress(qint64 m_bytesReceived = -1, qint64 m_bytesToReceive = -1);
|
|
void setStatusInfo(const QString &value);
|
|
void setStatus(DownloadStatus value);
|
|
void setNetworkError(QNetworkReply::NetworkError value);
|
|
|
|
// private fields
|
|
|
|
// concerning urls and meta information
|
|
QUrl m_initialUrl;
|
|
QString m_id;
|
|
QString m_title;
|
|
bool m_dontAcceptNewTitleFromFilenameAnymore;
|
|
QString m_uploader;
|
|
QString m_collectionName;
|
|
int m_views;
|
|
CppUtilities::TimeSpan m_duration;
|
|
QString m_rating;
|
|
int m_positionInCollection;
|
|
AuthenticationCredentials m_initAuthData;
|
|
|
|
// concerning available options
|
|
std::vector<OptionData> m_optionData;
|
|
size_t m_chosenOption;
|
|
bool m_selectedOptionChanged;
|
|
bool m_availableOptionsChanged;
|
|
|
|
// concerning status
|
|
DownloadStatus m_status;
|
|
DownloadStatus m_lastState;
|
|
qint64 m_bytesReceived;
|
|
qint64 m_bytesToReceive;
|
|
qint64 m_newBytesReceived;
|
|
qint64 m_newBytesToReceive;
|
|
double m_speed;
|
|
double m_shiftSpeed;
|
|
CppUtilities::TimeSpan m_shiftRemainingTime;
|
|
QString m_statusInfo;
|
|
QTime m_time;
|
|
QNetworkReply::NetworkError m_networkError;
|
|
bool m_initiated;
|
|
int m_progressUpdateInterval;
|
|
|
|
// concerning download
|
|
bool m_useDefaultUserAgent;
|
|
QString m_userAgent;
|
|
static int m_defaultUserAgent;
|
|
QNetworkProxy m_proxy;
|
|
QString m_targetPath;
|
|
DownloadRange m_range;
|
|
};
|
|
|
|
/*!
|
|
* \brief Returns an empty QUrl reference.
|
|
*/
|
|
inline const QUrl &Download::emptyUrl()
|
|
{
|
|
static const QUrl empty;
|
|
return empty;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns an empty QString reference.
|
|
*/
|
|
inline const QString &Download::emptyString()
|
|
{
|
|
static const QString empty;
|
|
return empty;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the initial URL.
|
|
*
|
|
* (e. g. "https://www.youtube.com/watch?v=eOCzuVrMP28")
|
|
*/
|
|
inline const QUrl &Download::initialUrl() const
|
|
{
|
|
return m_initialUrl;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the download URL for the chosen option (which might differ from the initial URL).
|
|
* \remarks
|
|
* - The download URL is possibly not available for all kinds of downloads.
|
|
* - Some downloads might use additional information (for instance if the POST method is used).
|
|
* - This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline const QUrl &Download::downloadUrl() const
|
|
{
|
|
return isValidOptionChosen() ? m_optionData.at(m_chosenOption).m_url : emptyUrl();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the download URL for the option with the specified \a index (which might differ from the initial URL).
|
|
* \remarks
|
|
* - The download URL is possibly not available for all kinds of downloads.
|
|
* - Some downloads might use additional information (for instance if the POST method is used).
|
|
* - This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline const QUrl &Download::downloadUrl(size_t optionIndex) const
|
|
{
|
|
return m_optionData.at(optionIndex).m_url;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns all available download URLs.
|
|
* \remarks For a more detailed description see downloadUrl().
|
|
* \sa downloadUrl()
|
|
*/
|
|
inline const std::vector<OptionData> &Download::options() const
|
|
{
|
|
return m_optionData;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns all available download URLs.
|
|
* \remarks For a more detailed description see downloadUrl().
|
|
* \sa downloadUrl()
|
|
*/
|
|
inline std::vector<OptionData> &Download::options()
|
|
{
|
|
return m_optionData;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the download ID if available.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
* (e. g. "eOCzuVrMP28" for the YouTube video "https://www.youtube.com/watch?v=eOCzuVrMP28")
|
|
*/
|
|
inline const QString &Download::id() const
|
|
{
|
|
return m_id;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the title of the download if available.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline const QString &Download::title() const
|
|
{
|
|
return m_title;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the name of the collection the download is part of if available.
|
|
*
|
|
* This is the playlist name for YouTube videos for example.
|
|
*
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline const QString &Download::collectionName() const
|
|
{
|
|
return m_collectionName;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the number of available options.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
* \sa availableOption()
|
|
*/
|
|
inline size_t Download::availableOptionCount() const
|
|
{
|
|
return m_optionData.size();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns an indication whether options are available.
|
|
*
|
|
* If no options are available this means that no way to download the requested data could be determined. The download
|
|
* can not be started in this case.
|
|
*
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
* \sa availableOption()
|
|
*/
|
|
inline bool Download::areOptionsAvailable() const
|
|
{
|
|
return !m_optionData.empty();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the name of the option with the specified \a index.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
* \sa availableOptionCount()
|
|
*/
|
|
inline const QString &Download::optionName(size_t optionIndex) const
|
|
{
|
|
if (optionIndex < m_optionData.size()) {
|
|
return m_optionData.at(optionIndex).m_name;
|
|
} else {
|
|
return emptyString();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether the available options have been changed since the last call of
|
|
* this method.
|
|
*/
|
|
inline bool Download::haveAvailableOptionsChanged()
|
|
{
|
|
bool res = m_availableOptionsChanged;
|
|
m_availableOptionsChanged = false;
|
|
return res;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns an indication whether a valid option has been chosen.
|
|
*/
|
|
inline bool Download::isValidOptionChosen() const
|
|
{
|
|
return availableOptionCount() > 0 && m_chosenOption < availableOptionCount();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the index of the chosen option.
|
|
*
|
|
* The index might be invalid. Check isValidOptionChosen() before.
|
|
*/
|
|
inline size_t Download::chosenOption() const
|
|
{
|
|
return m_chosenOption;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the name of the chosen option if a valid option has been chosen.
|
|
*/
|
|
inline const QString &Download::chosenOptionName() const
|
|
{
|
|
return optionName(m_chosenOption);
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns an indication whether the selected option has been changed since the last
|
|
* call of this method.
|
|
*/
|
|
inline bool Download::hasSelectedOptionChanged()
|
|
{
|
|
bool res = m_selectedOptionChanged;
|
|
m_selectedOptionChanged = false;
|
|
return res;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the user agent which is used for HTTP downloads or other downloads which allow sending such information.
|
|
*
|
|
* A custom user agent might be assigned using the setCustomUserAgent() method. If no custom user agent is assigned a
|
|
* randomly picked default user agent will be used. This behaviour can be disabled/enabled using the setDefaultUserAgentUsed()
|
|
* method.
|
|
*/
|
|
inline const QString &Download::userAgent()
|
|
{
|
|
if (m_userAgent.isEmpty() && isDefaultUserAgentUsed()) {
|
|
return defaultUserAgent();
|
|
}
|
|
return m_userAgent;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets a custom user agent used for HTTP downloads or other downloads which allow sending such information.
|
|
* \sa userAgent()
|
|
*/
|
|
inline void Download::setCustomUserAgent(const QString &value)
|
|
{
|
|
m_userAgent = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether a default user agent is used when no custom user agent is assigned.
|
|
* \sa userAgent()
|
|
*/
|
|
inline bool Download::isDefaultUserAgentUsed() const
|
|
{
|
|
return m_useDefaultUserAgent;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets whether a default user agent is used when no custom user agent is assigned.
|
|
* \sa userAgent()
|
|
*/
|
|
inline void Download::setDefaultUserAgentUsed(bool defaultUserAgentUsed)
|
|
{
|
|
m_useDefaultUserAgent = defaultUserAgentUsed;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the proxy.
|
|
*/
|
|
inline const QNetworkProxy &Download::proxy() const
|
|
{
|
|
return m_proxy;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the proxy.
|
|
* \remarks Setting the proxy when downloading does not affect the current download. You need to
|
|
* interrupt and restart the download in this case.
|
|
*/
|
|
inline void Download::setProxy(const QNetworkProxy &value)
|
|
{
|
|
m_proxy = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the name of the uploader if available.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline const QString &Download::uploader() const
|
|
{
|
|
return m_uploader;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the number of views for visual content if available.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline int Download::views() const
|
|
{
|
|
return m_views;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the duration if available.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline CppUtilities::TimeSpan Download::duration() const
|
|
{
|
|
return m_duration;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the rating if available.
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline const QString &Download::rating() const
|
|
{
|
|
return m_rating;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the position of the download in the collection the download is part of.
|
|
*
|
|
* (e. g. the track number for Grooveshark downloads)
|
|
*
|
|
* \remarks This information is possibly not available before the download is initiated.
|
|
*/
|
|
inline int Download::positionInCollection() const
|
|
{
|
|
return m_positionInCollection;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the status update interval in miliseconds.
|
|
*/
|
|
inline int Download::progressUpdateInterval() const
|
|
{
|
|
return m_progressUpdateInterval;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the status interval.
|
|
* \param value Specifies the status inverval in miliseconds.
|
|
*/
|
|
inline void Download::setProgressUpdateInterval(int value)
|
|
{
|
|
m_progressUpdateInterval = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the range.
|
|
* \sa DownloadRange
|
|
*/
|
|
inline DownloadRange &Download::range()
|
|
{
|
|
return m_range;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the download range.
|
|
*
|
|
* The range can only be set if this feature is supported.
|
|
* \sa supportsRange()
|
|
*
|
|
* \remarks Setting the range when downloading does not affect the current download. You need to
|
|
* abort and restart the download in this case.
|
|
*
|
|
* \returns Returns whether the range could be set.
|
|
*/
|
|
inline bool Download::setRange(const DownloadRange &value)
|
|
{
|
|
if (supportsRange()) {
|
|
m_range = value;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether a range can be set.
|
|
*/
|
|
inline bool Download::supportsRange() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether the download has been started.
|
|
*
|
|
* Returns false if the download has ended because the download might
|
|
* be restarted then.
|
|
*/
|
|
inline bool Download::isStarted() const
|
|
{
|
|
switch (status()) {
|
|
case DownloadStatus::Downloading:
|
|
case DownloadStatus::Waiting:
|
|
case DownloadStatus::FinishOuputFile:
|
|
case DownloadStatus::Interrupting:
|
|
case DownloadStatus::Aborting:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether the download is actually doing something.
|
|
*/
|
|
inline bool Download::isWorking() const
|
|
{
|
|
switch (status()) {
|
|
case DownloadStatus::Downloading:
|
|
case DownloadStatus::FinishOuputFile:
|
|
case DownloadStatus::Interrupting:
|
|
case DownloadStatus::Aborting:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether the download is actually downloading something.
|
|
*/
|
|
inline bool Download::isDownloading() const
|
|
{
|
|
switch (status()) {
|
|
case DownloadStatus::Downloading:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the ID.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa id()
|
|
*/
|
|
inline void Download::setId(const QString &value)
|
|
{
|
|
m_id = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the title.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa title()
|
|
*/
|
|
inline void Download::setTitle(const QString &value)
|
|
{
|
|
m_title = value;
|
|
m_dontAcceptNewTitleFromFilenameAnymore = true;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the title.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* The difference between this method and setTitle() is that this method
|
|
* does nothing if a title has been set previously using the setTitle() method.
|
|
* This might be useful since title information which is only derived from a
|
|
* filename should generally not overwrite a title which has been obtained previously
|
|
* from a better souce (for example the video meta data returned by YouTube in
|
|
* case of a YouTube download).
|
|
*
|
|
* \sa setTitle()
|
|
* \sa title()
|
|
*/
|
|
inline void Download::setTitleFromFilename(const QString &valueObtainedFromFilename)
|
|
{
|
|
if (!m_dontAcceptNewTitleFromFilenameAnymore) {
|
|
m_title = valueObtainedFromFilename;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the uploader.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa uploader().
|
|
*/
|
|
inline void Download::setUploader(const QString &value)
|
|
{
|
|
m_uploader = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the uploader.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa uploader().
|
|
*/
|
|
inline void Download::setViews(int value)
|
|
{
|
|
m_views = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the duration.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa duration().
|
|
*/
|
|
inline void Download::setDuration(CppUtilities::TimeSpan value)
|
|
{
|
|
m_duration = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the rating.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa rating().
|
|
*/
|
|
inline void Download::setRating(const QString &value)
|
|
{
|
|
m_rating = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the position of the download in the collection the download is part of.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa positionInCollection().
|
|
*/
|
|
inline void Download::setPositionInCollection(int value)
|
|
{
|
|
m_positionInCollection = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets name of the collection the download is part of.
|
|
*
|
|
* Might be called when subclassing. To provide meta data from an external source use provideMetaData().
|
|
*
|
|
* \sa collectionName().
|
|
*/
|
|
inline void Download::setCollectionName(const QString &value)
|
|
{
|
|
m_collectionName = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns an indication whether the download is initiated.
|
|
*
|
|
* \remarks A download which has been failed might be initiated or not - depending
|
|
* whether the failure occured during initialization or during the acutal download.
|
|
*/
|
|
inline bool Download::isInitiated() const
|
|
{
|
|
return m_initiated;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the target path. The download will store downloaded data in that file.
|
|
*
|
|
* The target path might be set when calling the start() method
|
|
* or using the setTargetPath() method.
|
|
*
|
|
* \sa setTargetPath()
|
|
*/
|
|
inline const QString &Download::targetPath() const
|
|
{
|
|
return m_targetPath;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the target path.
|
|
* \remarks The target path is ignored if there is already an output device present.
|
|
* \sa targetPath()
|
|
*/
|
|
inline void Download::setTargetPath(const QString &targetPath)
|
|
{
|
|
m_targetPath = targetPath;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the current status.
|
|
* \sa DownloadStatus
|
|
*/
|
|
inline DownloadStatus Download::status() const
|
|
{
|
|
return m_status;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the current status.
|
|
*
|
|
* This method is only intented for internal use. Use the methods start(), stop(), abort(), ... to
|
|
* control the status of the download. When subclassing use the report methods.
|
|
*/
|
|
inline void Download::setStatus(DownloadStatus value)
|
|
{
|
|
if (value != m_status) {
|
|
m_lastState = m_status;
|
|
m_status = value;
|
|
emit statusChanged(this);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the last status.
|
|
* \sa status()
|
|
*/
|
|
inline DownloadStatus Download::lastStatus() const
|
|
{
|
|
return m_lastState;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the progress percentage if available; otherwise -1.
|
|
*/
|
|
inline int Download::progressPercentage() const
|
|
{
|
|
return (m_bytesReceived > 0 && m_bytesToReceive > 0) ? (static_cast<double>(m_bytesReceived) / static_cast<double>(m_bytesToReceive) * 100.0)
|
|
: -1;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the current speed if available; otherwise 0.
|
|
*/
|
|
inline double Download::speed() const
|
|
{
|
|
return m_status == DownloadStatus::Downloading ? m_speed : 0.0;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the alteration of the speed since the last call of this method.
|
|
* \sa speed()
|
|
*/
|
|
inline double Download::shiftSpeed()
|
|
{
|
|
double absolute = speed();
|
|
double shift = absolute - m_shiftSpeed;
|
|
m_shiftSpeed = absolute;
|
|
return shift;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the estimated remaining time.
|
|
*/
|
|
inline CppUtilities::TimeSpan Download::remainingTime() const
|
|
{
|
|
return (m_status == DownloadStatus::Downloading && m_bytesToReceive != -1)
|
|
? CppUtilities::TimeSpan::fromSeconds(static_cast<double>(m_bytesToReceive) / (m_speed * 125.0))
|
|
: CppUtilities::TimeSpan();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the alteration of the estimated remaining time since the last call of this method.
|
|
* \sa remainingTime()
|
|
*/
|
|
inline CppUtilities::TimeSpan Download::shiftRemainingTime()
|
|
{
|
|
CppUtilities::TimeSpan absolute = remainingTime();
|
|
CppUtilities::TimeSpan shift = absolute - m_shiftRemainingTime;
|
|
m_shiftRemainingTime = absolute;
|
|
return shift;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the number of bytes received since the downlod has been started.
|
|
*/
|
|
inline qint64 Download::bytesReceived() const
|
|
{
|
|
return m_bytesReceived;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the number of bytes received since the last call of this method or
|
|
* if the method hasn't been called yet since the download has been started.
|
|
* \sa bytesReceived()
|
|
*/
|
|
inline qint64 Download::newBytesReceived()
|
|
{
|
|
qint64 shift = m_bytesReceived - m_newBytesReceived;
|
|
m_newBytesReceived = m_bytesReceived;
|
|
return shift;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the total number of bytes to receive.
|
|
*/
|
|
inline qint64 Download::bytesToReceive() const
|
|
{
|
|
return m_bytesToReceive;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the alteration of the total number of bytes to receive.
|
|
* \sa bytesToReceive()
|
|
*/
|
|
inline qint64 Download::newBytesToReceive()
|
|
{
|
|
qint64 shift = m_bytesToReceive - m_newBytesToReceive;
|
|
m_newBytesToReceive = m_bytesToReceive;
|
|
return shift;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the number of miliseconds since the last progress update.
|
|
*/
|
|
inline int Download::lastProgressUpdate() const
|
|
{
|
|
return m_time.elapsed();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns an indication whether a status information is available.
|
|
*
|
|
* A status information is usually available if the download failed. In this case
|
|
* the status info contains the reason for the fail.
|
|
*/
|
|
inline bool Download::hasStatusInfo() const
|
|
{
|
|
return !m_statusInfo.isEmpty();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the status info.
|
|
* \sa hasStatusInfo()
|
|
*/
|
|
inline const QString &Download::statusInfo() const
|
|
{
|
|
return m_statusInfo;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the status info.
|
|
*
|
|
* This method is only intented for internal use. Use the report methods when subclassing.
|
|
*/
|
|
inline void Download::setStatusInfo(const QString &value)
|
|
{
|
|
if (m_statusInfo != value) {
|
|
m_statusInfo = value;
|
|
emit statusInfoChanged(this);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns what kind of network error occured.
|
|
*
|
|
* If no network error occured QNetworkReply::NoError is returned.
|
|
*/
|
|
inline QNetworkReply::NetworkError Download::networkError() const
|
|
{
|
|
return m_networkError;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the status info.
|
|
*
|
|
* This method is only intented for internal use. Use the report methods when subclassing.
|
|
*/
|
|
inline void Download::setNetworkError(QNetworkReply::NetworkError value)
|
|
{
|
|
m_networkError = value;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the authentication credentials provided for initialization using provideAuthenticationCredentials().
|
|
*/
|
|
inline const AuthenticationCredentials &Download::initialAuthenticationCredentials() const
|
|
{
|
|
return m_initAuthData;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the authentication credentials provided for initialization using provideAuthenticationCredentials().
|
|
*/
|
|
inline AuthenticationCredentials &Download::initialAuthenticationCredentials()
|
|
{
|
|
return m_initAuthData;
|
|
}
|
|
} // namespace Network
|
|
|
|
#endif // DOWNLOAD_H
|