File indexing completed on 2024-04-28 15:15:44

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2006-2007 Torsten Rahn <tackat@kde.org>
 // SPDX-FileCopyrightText: 2007 Inge Wallin <ingwa@kde.org>
 // SPDX-FileCopyrightText: 2008, 2009 Jens-Michael Hoffmann <jensmh@gmx.de>
 // SPDX-FileCopyrightText: 2008 Pino Toscano <pino@kde.org>
 //
 
 #include "HttpJob.h"
 
 #include "MarbleDebug.h"
 #include "HttpDownloadManager.h"
 
 #include <QNetworkAccessManager>
 
 using namespace Marble;
 
 class Marble::HttpJobPrivate
 {
  public:
     HttpJobPrivate( const QUrl & sourceUrl, const QString & destFileName,
                     const QString &id, QNetworkAccessManager *networkAccessManager );
 
     QUrl           m_sourceUrl;
     QString        m_destinationFileName;
     QString        m_initiatorId;
     int            m_trialsLeft;
     DownloadUsage  m_downloadUsage;
     QString m_userAgent;
     QNetworkAccessManager *const m_networkAccessManager;
     QNetworkReply *m_networkReply;
 };
 
 HttpJobPrivate::HttpJobPrivate( const QUrl & sourceUrl, const QString & destFileName,
                                 const QString &id, QNetworkAccessManager *networkAccessManager )
     : m_sourceUrl( sourceUrl ),
       m_destinationFileName( destFileName ),
       m_initiatorId( id ),
       m_trialsLeft( 3 ),
       m_downloadUsage( DownloadBrowse ),
       // FIXME: remove initialization depending on if empty pluginId
       // results in valid user agent string
       m_userAgent( "unknown" ),
       m_networkAccessManager( networkAccessManager ),
       m_networkReply( nullptr )
 {
 }
 
 
 HttpJob::HttpJob( const QUrl & sourceUrl, const QString & destFileName, const QString &id, QNetworkAccessManager *networkAccessManager )
     : d( new HttpJobPrivate( sourceUrl, destFileName, id, networkAccessManager ) )
 {
 }
 
 HttpJob::~HttpJob()
 {
     delete d;
 }
 
 QUrl HttpJob::sourceUrl() const
 {
     return d->m_sourceUrl;
 }
 
 void HttpJob::setSourceUrl( const QUrl &url )
 {
     d->m_sourceUrl = url;
 }
 
 QString HttpJob::initiatorId() const
 {
     return d->m_initiatorId;
 }
 
 void HttpJob::setInitiatorId( const QString &id )
 {
     d->m_initiatorId = id;
 }
 
 QString HttpJob::destinationFileName() const
 {
     return d->m_destinationFileName;
 }
 
 void HttpJob::setDestinationFileName( const QString &fileName )
 {
     d->m_destinationFileName = fileName;
 }
 
 bool HttpJob::tryAgain()
 {
     if( d->m_trialsLeft > 0 ) {
     d->m_trialsLeft--;
     return true;
     }
     else {
     return false;
     }
 }
 
 DownloadUsage HttpJob::downloadUsage() const
 {
     return d->m_downloadUsage;
 }
 
 void HttpJob::setDownloadUsage( const DownloadUsage usage )
 {
     d->m_downloadUsage = usage;
 }
 
 void HttpJob::setUserAgentPluginId( const QString & pluginId ) const
 {
     d->m_userAgent = pluginId;
 }
 
 QByteArray HttpJob::userAgent() const
 {
     switch ( d->m_downloadUsage ) {
     case DownloadBrowse:
         return HttpDownloadManager::userAgent("Browser", d->m_userAgent);
     case DownloadBulk:
         return HttpDownloadManager::userAgent("BulkDownloader", d->m_userAgent);
     default:
         qCritical() << "Unknown download usage value:" << d->m_downloadUsage;
         return HttpDownloadManager::userAgent("unknown", d->m_userAgent);
     }
 }
 
 void HttpJob::execute()
 {
     QNetworkRequest request( d->m_sourceUrl );
     request.setAttribute( QNetworkRequest::HttpPipeliningAllowedAttribute, true );
     request.setRawHeader( "User-Agent", userAgent() );
     d->m_networkReply = d->m_networkAccessManager->get( request );
 
     connect( d->m_networkReply, SIGNAL(downloadProgress(qint64,qint64)),
              SLOT(downloadProgress(qint64,qint64)));
     connect( d->m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
              SLOT(error(QNetworkReply::NetworkError)));
     connect( d->m_networkReply, SIGNAL(finished()),
              SLOT(finished()));
 }
 void HttpJob::downloadProgress( qint64 bytesReceived, qint64 bytesTotal )
 {
     Q_UNUSED(bytesReceived);
     Q_UNUSED(bytesTotal);
 //     mDebug() << "downloadProgress" << destinationFileName()
 //              << bytesReceived << '/' << bytesTotal;
 }
 
 void HttpJob::error( QNetworkReply::NetworkError code )
 {
     mDebug() << "error" << destinationFileName() << code;
 }
 
 void HttpJob::finished()
 {
     QNetworkReply::NetworkError const error = d->m_networkReply->error();
 //     mDebug() << "finished" << destinationFileName()
 //              << "error" << error;
 
     const QVariant httpPipeliningWasUsed =
         d->m_networkReply->attribute( QNetworkRequest::HttpPipeliningWasUsedAttribute );
     if ( !httpPipeliningWasUsed.isNull() )
         mDebug() << "http pipelining used:" << httpPipeliningWasUsed.toBool();
 
     switch ( error ) {
     case QNetworkReply::NoError: {
         // check if we are redirected
         const QVariant redirectionAttribute =
             d->m_networkReply->attribute( QNetworkRequest::RedirectionTargetAttribute );
         if ( !redirectionAttribute.isNull() ) {
             emit redirected( this, redirectionAttribute.toUrl() );
         }
         else {
             // no redirection occurred
             const QByteArray data = d->m_networkReply->readAll();
             emit dataReceived( this, data );
         }
     }
         break;
 
     default:
         emit jobDone( this, 1 );
     }
 
     d->m_networkReply->disconnect( this );
     // No delete. This method is called by a signal QNetworkReply::finished.
     d->m_networkReply->deleteLater();
     d->m_networkReply = nullptr;
 }
 
 #include "moc_HttpJob.cpp"