bool PictureContent::loadFromNetwork(const QString & url, QNetworkReply * reply, const QString & title, int width, int height) { dropNetworkConnection(); delete m_photo; m_cachedPhoto = QPixmap(); m_opaquePhoto = false; m_photo = 0; m_fileUrl = url; m_netWidth = width; m_netHeight = height; // start a download if not passed as a paramenter if (!reply) { // the QNAM will be auto-deleted on closure QNetworkAccessManager * nam = new QNetworkAccessManager(this); QNetworkRequest request(url); m_netReply = nam->get(request); } else m_netReply = reply; // set title if (!title.isEmpty()) { setFrameTextEnabled(true); setFrameText(title); } #if QT_VERSION >= 0x040600 // Immediate Decode: just handle the reply if done if (m_netReply->isFinished()) return slotLoadNetworkData(); #else // No Precaching ensures signals to be emitted later #endif // Deferred Decode: listen to the network job setAcceptHoverEvents(false); setControlsVisible(false); m_progress = 0.01; connect(m_netReply, SIGNAL(finished()), this, SLOT(slotLoadNetworkData())); connect(m_netReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(slotNetworkError())); connect(m_netReply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(slotNetworkProgress(qint64,qint64))); // reset size, if got the network one if (m_netWidth > 0 && m_netHeight > 0) resetContentsRatio(); return true; }
ShowPicture::ShowPicture(QString bigUrl, QString midUrl, QWidget *parent) : QWidget(parent) { this->setWindowFlags(Qt::FramelessWindowHint); this->bigUrl = bigUrl; this->midUrl = midUrl; if(midUrl.toUpper().endsWith(".GIF")) this->isGif = true; else this->isGif = false; this->setWindowTitle(tr("图片")); progressBar = new QProgressBar(this); progressBar->setValue(0); label = new QLabel(this); label->setText("正在下载......"); this->showGif = new QLabel(this); this->showGif->hide(); this->movie = new QMovie(this); this->gifImageFile = new QBuffer(&imageByteArray, this); layout = new QVBoxLayout(this); layout->addWidget(label); layout->addWidget(progressBar); toolBar = new QToolBar(this); saveFile = new QAction(this); bigPicture = new QAction(this); saveFile->setText("保存图片"); bigPicture->setText("查看大图"); QObject::connect(saveFile, SIGNAL(triggered()), this, SLOT(saveImage())); QObject::connect(bigPicture, SIGNAL(triggered()), this, SLOT(showBigPicture())); toolBar->addAction(saveFile); toolBar->addAction(bigPicture); toolBar->hide(); view = new QGraphicsView(this); scene = new QGraphicsScene(this); view->setScene(scene); view->hide(); http = new Http(this); QObject::connect(http, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(updateProgressBar(qint64,qint64))); //QObject::connect(http, SIGNAL(finished()), this, SLOT(showAfterDownload())); timer = new QTimer(this); timer->setSingleShot(true); QObject::connect(timer, SIGNAL(timeout()), this, SLOT(downloadFile())); timer->start(500); }
void LegacyUpdate::lwjglStart() { LegacyInstance *inst = (LegacyInstance *)m_inst; lwjglVersion = inst->lwjglVersion(); lwjglTargetPath = PathCombine(MMC->settings()->get("LWJGLDir").toString(), lwjglVersion); lwjglNativesPath = PathCombine(lwjglTargetPath, "natives"); // if the 'done' file exists, we don't have to download this again QFileInfo doneFile(PathCombine(lwjglTargetPath, "done")); if (doneFile.exists()) { jarStart(); return; } auto list = MMC->lwjgllist(); if (!list->isLoaded()) { emitFailed("Too soon! Let the LWJGL list load :)"); return; } setStatus(tr("Downloading new LWJGL...")); auto version = list->getVersion(lwjglVersion); if (!version) { emitFailed("Game update failed: the selected LWJGL version is invalid."); return; } QString url = version->url(); QUrl realUrl(url); QString hostname = realUrl.host(); auto worker = MMC->qnam(); QNetworkRequest req(realUrl); req.setRawHeader("Host", hostname.toLatin1()); req.setHeader(QNetworkRequest::UserAgentHeader, "MultiMC/5.0 (Cached)"); QNetworkReply *rep = worker->get(req); m_reply = std::shared_ptr<QNetworkReply>(rep); connect(rep, SIGNAL(downloadProgress(qint64, qint64)), SIGNAL(progress(qint64, qint64))); connect(worker.get(), SIGNAL(finished(QNetworkReply *)), SLOT(lwjglFinished(QNetworkReply *))); // connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), // SLOT(downloadError(QNetworkReply::NetworkError))); }
void LegacyUpdate::lwjglFinished(QNetworkReply *reply) { if (m_reply.get() != reply) { return; } if (reply->error() != QNetworkReply::NoError) { emitFailed("Failed to download: " + reply->errorString() + "\nSometimes you have to wait a bit if you download many LWJGL versions in " "a row. YMMV"); return; } auto worker = MMC->qnam(); // Here i check if there is a cookie for me in the reply and extract it QList<QNetworkCookie> cookies = qvariant_cast<QList<QNetworkCookie>>(reply->header(QNetworkRequest::SetCookieHeader)); if (cookies.count() != 0) { // you must tell which cookie goes with which url worker->cookieJar()->setCookiesFromUrl(cookies, QUrl("sourceforge.net")); } // here you can check for the 302 or whatever other header i need QVariant newLoc = reply->header(QNetworkRequest::LocationHeader); if (newLoc.isValid()) { QString redirectedTo = reply->header(QNetworkRequest::LocationHeader).toString(); QUrl realUrl(redirectedTo); QString hostname = realUrl.host(); QNetworkRequest req(redirectedTo); req.setRawHeader("Host", hostname.toLatin1()); req.setHeader(QNetworkRequest::UserAgentHeader, "MultiMC/5.0 (Cached)"); QNetworkReply *rep = worker->get(req); connect(rep, SIGNAL(downloadProgress(qint64, qint64)), SIGNAL(progress(qint64, qint64))); m_reply = std::shared_ptr<QNetworkReply>(rep); return; } QFile saveMe("lwjgl.zip"); saveMe.open(QIODevice::WriteOnly); saveMe.write(m_reply->readAll()); saveMe.close(); setStatus(tr("Installing new LWJGL...")); extractLwjgl(); jarStart(); }
void ParserAbstract::sendHttpRequest(QUrl url, QByteArray data) { QNetworkRequest request; request.setUrl(url); request.setRawHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0"); request.setRawHeader("Cache-Control", "no-cache"); if (data.isNull()) { lastRequest = NetworkManager->get(request); } else { lastRequest = NetworkManager->post(request, data); } requestTimeout->start(30000); connect(lastRequest, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(networkReplyDownloadProgress(qint64,qint64))); }
/* Prepare network-reply: */ void UINetworkRequest::prepareNetworkReply() { /* Make network-request: */ m_pReply = new UINetworkReply(m_request, m_type); AssertMsg(m_pReply, ("Unable to make network-request!\n")); /* Prepare listeners for m_pReply: */ connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(sltHandleNetworkReplyProgress(qint64, qint64))); connect(m_pReply, SIGNAL(finished()), this, SLOT(sltHandleNetworkReplyFinish())); /* Set as running: */ m_fRunning = true; /* Notify general network-requests listeners: */ emit sigStarted(m_uuid); /* Notify particular network-request listeners: */ emit sigStarted(); }
bool Http::get(const QString& url) { m_Data.clear(); m_Request.setUrl(url); m_pReply = m_NetworkManager.get(m_Request); QEventLoop loop; connect(m_pReply, SIGNAL(finished()), &loop, SLOT(quit())); connect(m_pReply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(onDownloadProgress(qint64,qint64))); loop.exec(); m_Data.append(m_pReply->readAll()); m_Error = m_pReply->error(); m_Message = m_pReply->errorString(); return m_Error == QNetworkReply::NoError; }
void DownLoadFun::down(STATUSID id, QString url) { if(reply != NULL) { reply->abort(); } m_id = id; QNetworkAccessManager *manager = new QNetworkAccessManager; reply = manager->get(QNetworkRequest(url)); connect(reply, SIGNAL(finished()), this, SLOT(httpFinished())); connect(reply,SIGNAL(downloadProgress(qint64,qint64)), this,SLOT(updateDataReadProgress(qint64,qint64))); }
bool QgsWcsCapabilities::sendRequest( QString const & url ) { QgsDebugMsg( "url = " + url ); mError = ""; QNetworkRequest request( url ); if ( !setAuthorization( request ) ) { mError = tr( "Download of capabilities failed: network request update failed for authentication config" ); QgsMessageLog::logMessage( mError, tr( "WCS" ) ); return false; } request.setAttribute( QNetworkRequest::CacheSaveControlAttribute, true ); request.setAttribute( QNetworkRequest::CacheLoadControlAttribute, mCacheLoadControl ); QgsDebugMsg( QString( "mCacheLoadControl = %1" ).arg( mCacheLoadControl ) ); QgsDebugMsg( QString( "getcapabilities: %1" ).arg( url ) ); mCapabilitiesReply = QgsNetworkAccessManager::instance()->get( request ); connect( mCapabilitiesReply, SIGNAL( finished() ), this, SLOT( capabilitiesReplyFinished() ) ); connect( mCapabilitiesReply, SIGNAL( downloadProgress( qint64, qint64 ) ), this, SLOT( capabilitiesReplyProgress( qint64, qint64 ) ) ); while ( mCapabilitiesReply ) { QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents ); } if ( mCapabilitiesResponse.isEmpty() ) { if ( mError.isEmpty() ) { mErrorFormat = "text/plain"; mError = tr( "empty capabilities document" ); } return false; } if ( mCapabilitiesResponse.startsWith( "<html>" ) || mCapabilitiesResponse.startsWith( "<HTML>" ) ) { mErrorFormat = "text/html"; mError = mCapabilitiesResponse; return false; } return true; }
void QQuickAnimatedImage::load() { Q_D(QQuickAnimatedImage); if (d->url.isEmpty()) { if (d->progress != 0) { d->progress = 0; emit progressChanged(d->progress); } d->setImage(QImage()); d->status = Null; emit statusChanged(d->status); if (sourceSize() != d->oldSourceSize) { d->oldSourceSize = sourceSize(); emit sourceSizeChanged(); } if (isPlaying() != d->oldPlaying) emit playingChanged(); } else { QString lf = QQmlFile::urlToLocalFileOrQrc(d->url); if (!lf.isEmpty()) { d->_movie = new QMovie(lf); movieRequestFinished(); } else { if (d->status != Loading) { d->status = Loading; emit statusChanged(d->status); } if (d->progress != 0) { d->progress = 0; emit progressChanged(d->progress); } QNetworkRequest req(d->url); req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true); d->reply = qmlEngine(this)->networkAccessManager()->get(req); QObject::connect(d->reply, SIGNAL(finished()), this, SLOT(movieRequestFinished())); QObject::connect(d->reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(requestProgress(qint64,qint64))); } } }
/** Report download progress to the user */ void HttpClient::slotDownloadProgress( qint64 bytesReceived, qint64 bytesTotal ) { // qDebug() << "HttpClient::slotDownloadProgress" << bytesReceived << bytesTotal; if ( _progressDialog != static_cast<QProgressDialog *> (0) ) { // Report results to the progress dialog. _progressDialog->setMaximum( bytesTotal ); _progressDialog->setValue( bytesReceived ); } else { // Emit this signal to the outside, when no progress dialog is set up. emit downloadProgress( bytesReceived, bytesTotal ); } timer->start(); }
void GetFileTask::sendRequest() { QNetworkRequest request(url_); if (!network_mgr_) { static QNetworkAccessManager *manager = new QNetworkAccessManager(qApp); network_mgr_ = manager; NetworkManager::instance()->addWatch(network_mgr_); } reply_ = network_mgr_->get(request); connect(reply_, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(onSslErrors(const QList<QSslError>&))); connect(reply_, SIGNAL(readyRead()), this, SLOT(httpReadyRead())); connect(reply_, SIGNAL(downloadProgress(qint64, qint64)), this, SIGNAL(progressUpdate(qint64, qint64))); connect(reply_, SIGNAL(finished()), this, SLOT(httpRequestFinished())); }
void dbmanager::doDownload(const QVariant& v) { if (v.type() == QVariant::StringList) { QNetworkAccessManager *manager= new QNetworkAccessManager(this); QUrl url = v.toStringList().at(current); filename = url.toString().remove("http://restbase.wikitolearn.org/en.wikitolearn.org/v1/media/math/render/svg/"); m_network_reply = manager->get(QNetworkRequest(QUrl(url))); connect(m_network_reply, SIGNAL(downloadProgress (qint64, qint64)),this, SLOT(updateDownloadProgress(qint64, qint64))); // checks download progress connect(m_network_reply,SIGNAL(finished()),this,SLOT(downloadFinished())); // signal that download is finished } }
bool NetworkHandler::startJSONDownload() { QNetworkRequest req(m_Url); req.setRawHeader(m_headerName,m_headerValue); m_pNetworkReply = m_Mgr.get(req); if(m_pNetworkReply) { QObject::connect(m_pNetworkReply,SIGNAL(finished()),this,SLOT(readFinished())); QObject::connect(m_pNetworkReply,SIGNAL(downloadProgress(qint64,qint64)),this,SLOT(downloadProgress(qint64,qint64))); QObject::connect(m_pNetworkReply,SIGNAL(error(QNetworkReply::NetworkError)),this,SLOT(error(QNetworkReply::NetworkError))); QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(timeout())); } else { qDebug() << "Failed to create get request!"; emit readyRead(QByteArray()); } }
void video::download() { _step = 3; handler->clearDownloads(); connect(handler, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(changeProgress(qint64, qint64))); if (!this->_supportedQualities.at(_quality).videoUrl.isEmpty()) { qDebug() << "Downloading video file: " << this->_supportedQualities.at(_quality).videoUrl; handler->addDownload(this->_supportedQualities.at(_quality).videoUrl, this->_supportedQualities.at(_quality).chunkedDownload); } if (!this->_supportedQualities.at(_quality).audioUrl.isEmpty()) { qDebug() << "Downloading audio file: " << this->_supportedQualities.at(_quality).audioUrl; handler->addDownload(this->_supportedQualities.at(_quality).audioUrl, this->_supportedQualities.at(_quality).chunkedDownload); } }
//reply finished void Downloader::finishedSlot(){ if (reply->error() == QNetworkReply::NoError){ QVariant possibleRedirectUrl = reply->attribute(QNetworkRequest::RedirectionTargetAttribute); if (!possibleRedirectUrl.toUrl().isEmpty()) { //there is redirect //make new request //emit sendInfo("Redirected to "+possibleRedirectUrl.toUrl().toString()); reply->deleteLater(); reply = nam.get(QNetworkRequest(possibleRedirectUrl.toUrl())); //when this reply is finished this slot will get re-triggered emit sendInfo("Redirecting..."); emit sendInfo(""); tmpBuffer.clear(); //CLEAR THE GODDAMN BUFFER!!!! file->resize(0); //reconnect since deleting reply disconnects all slots QObject::connect(reply, SIGNAL(finished()), this, SLOT(finishedSlot())); QObject::connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(errorSlot(QNetworkReply::NetworkError))); QObject::connect(reply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(progressSlot(qint64, qint64))); } else { //all ok emit sendInfo("Downloader exiting with no errors"); //Read whatever is left tmpBuffer.append(reply->readAll()); file->write(tmpBuffer); file->close(); emit sendInfo("Handing off work to updater"); emit finisheddl(); } } else { if (!erroremitted) { emit sendInfo("Network err code: "+reply->errorString()); erroremitted=true; emit finisheddl(); } } }
void LoginWindow::doSignIn(QString username,QString password) { if(loginInProgress) return; if (!username.isEmpty() && !password.isEmpty()) { QUrl m_loginUrl = QUrl ( QString(Constants::LOGIN_PATH) + "u=" + username + "&p=" + password ); reply = manager.get(QNetworkRequest(m_loginUrl)); connect(reply, SIGNAL(finished()), this, SLOT(httpFinished())); connect(reply, SIGNAL(readyRead()), this, SLOT(httpReadyRead())); connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(updateProgress(qint64,qint64))); } }
int HttpCommunicator::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QObject::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: finishedRequest(); break; case 1: finishedSlot((*reinterpret_cast< QNetworkReply*(*)>(_a[1]))); break; case 2: downloadProgress((*reinterpret_cast< qint64(*)>(_a[1])),(*reinterpret_cast< qint64(*)>(_a[2]))); break; case 3: uploadProgress((*reinterpret_cast< qint64(*)>(_a[1])),(*reinterpret_cast< qint64(*)>(_a[2]))); break; case 4: downloadReadyRead(); break; case 5: construct2(); break; default: ; } _id -= 6; } return _id; }
void Downloader::doHttpRequest(QString url){ QNetworkRequest request; request.setUrl(QUrl(url)); request.setRawHeader( "User-Agent" , "Mozilla Firefox" ); // :) Probabilly is not really need! qInfo() << endl << "Starting http request to" << url; reply.reset( httpClient.get(request)); if(reply->error() != QNetworkReply::NoError){ throw std::runtime_error(reply->errorString().toStdString()); } connect(reply.data(), SIGNAL(finished()), this, SIGNAL(downloadFinished())); connect(reply.data(), SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(downloadProgressed(qint64,qint64))); connect(reply.data(), SIGNAL(readyRead()), this, SLOT(bytesAvailable())); connect(reply.data(), SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(replyError(QNetworkReply::NetworkError))); emit downloadStarted(); }
void ReplyFetcher::start(QNetworkAccessManager *nam, QNetworkRequest request, QByteArray postData) { httpStatusCode_= 0; errorText_.clear(); receivedData_.clear(); success_ = true; // not in finished() signal handler, it might be not called according to the docs // besides, I've added timeout feature lastNetworkTime_ = QDateTime::currentMSecsSinceEpoch(); ticker_->start(1000); if(postData.isNull()) { reply = QSharedPointer<QNetworkReply>(nam->get(request), &QObject::deleteLater); } else { reply = QSharedPointer<QNetworkReply>(nam->post(request, postData), &QObject::deleteLater); } connect(reply.data(), SIGNAL(finished()), this, SLOT(onFinished())); connect(reply.data(), SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onError())); connect(reply.data(), SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(onSslErrors(QList<QSslError>))); connect(reply.data(), SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(onDownloadProgress(qint64,qint64))); }
void Downloader::startDownload (const QUrl& url) { /* Reset UI */ m_ui->progressBar->setValue (0); m_ui->stopButton->setText (tr ("Stop")); m_ui->downloadLabel->setText (tr ("Downloading updates")); m_ui->timeLabel->setText (tr ("Time remaining") + ": " + tr ("unknown")); /* Start download */ m_startTime = QDateTime::currentDateTime().toTime_t(); m_reply = m_manager->get (QNetworkRequest (url)); /* Update UI when download progress changes or download finishes */ connect (m_reply, SIGNAL (downloadProgress (qint64, qint64)), this, SLOT (updateProgress (qint64, qint64))); connect (m_reply, SIGNAL (finished()), this, SLOT (onDownloadFinished())); showNormal(); }
void ProgressDialog::doUrlDownload(Download download) { QString userAgent = "FlashTool "; userAgent.append(FLASHTOOL_VERSION); this->reset(); QNetworkRequest request; request.setUrl(download.uri); request.setRawHeader("User-Agent", userAgent.toLatin1()); request.setRawHeader("Cache-Control", "no-cache"); request.setRawHeader("Content-Type", "text/xml"); if (download.body.isEmpty()) { this->m_networkRequest = this->m_networkManager->get(request); } else { this->m_networkRequest = this->m_networkManager->post(request, download.body.toLatin1()); } m_downloadRequestTimeout->start(30000); connect(this->m_networkRequest, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(networkReplyDownloadProgress(qint64,qint64))); }
void KisGmicUpdater::start() { QUrl url(m_url); QNetworkRequest request(url); QString userAgent("org.krita.gmic/"); QString version = QString("%0.%1.%2.%3").arg(gmic_version/1000).arg((gmic_version/100)%10).arg((gmic_version/10)%10).arg(gmic_version%10); userAgent.append(version); dbgPlugins << "userAgent" << userAgent.toLatin1(); request.setRawHeader("User-Agent", userAgent.toLatin1()); QNetworkReply * getReply = m_manager.get(request); connect(getReply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(reportProgress(qint64,qint64))); connect(getReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(slotError(QNetworkReply::NetworkError))); }
void AdBlockDownloader::downloadFile(const QString& path, const QString &filename, const QString& localfile) { this->_progressvalue = 0; this->_progresstotal = 0; emit connectionStarted(); this->_localfile = localfile; this->_tempfile.setFileName(localfile); this->_tempfile.open(QFile::WriteOnly | QFile::Truncate); QUrl url(QString("%1/%2").arg(path, filename)); QNetworkRequest request(url); this->_downloadreply = this->_networkmanager.get(request); connect(this->_downloadreply, SIGNAL(readyRead()), this, SLOT(onNetworkReplyReadyRead())); connect(this->_downloadreply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(onDownloadProgress(qint64,qint64))); connect(this->_downloadreply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onDownloadError(QNetworkReply::NetworkError))); }
void TransferItem::start() { switch (method) { case Get: reply = nam.get(request); connect(reply, SIGNAL(readyRead()), this, SLOT(readyRead())); connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(progress(qint64,qint64))); break; case Put: reply = nam.put(request, inputFile); connect(reply, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(progress(qint64,qint64))); break; case Post: reply = nam.post(request, inputFile); connect(reply, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(progress(qint64,qint64))); break; } connect(reply, SIGNAL(finished()), this, SLOT(finished())); }
void UpdaterDialog::doDownload(const QModelIndex &index) { QUrl downloadURL = getDownloadUrl(index); if (!validateURL(downloadURL)) { return; } //QString targetFolder = QDir::toNativeSeparators(QApplication::applicationDirPath() + "/data/downloads"); //QString targetName = "test.zip"; /** * Download Request */ // setup Proxy // use system proxy (by default) "--use-proxy=on" //QNetworkProxyFactory::setUseSystemConfiguration(true); // setup Network Request QNetworkRequest request(downloadURL); // setup download folder QString downloadFolder(QCoreApplication::applicationDirPath()+QDir::separator()+"downloads"); if (!QDir(downloadFolder).exists()) { QDir(downloadFolder).mkpath("."); } downloadManager.setDownloadFolder(downloadFolder); downloadManager.setDownloadMode(Downloader::DownloadItem::DownloadMode::SkipIfExists); // enqueue download request downloadManager.get(request); // setup progressbar Downloader::TransferItem *transfer = downloadManager.findTransfer(downloadURL); ProgressBarUpdater *progressBar = new ProgressBarUpdater(this, index.row()); connect(transfer, SIGNAL(downloadProgress(QMap<QString, QVariant>)), progressBar, SLOT(updateProgress(QMap<QString, QVariant>))); connect(transfer, SIGNAL(transferFinished(Downloader::TransferItem *t)), progressBar, SLOT(downloadFinished(Downloader::TransferItem *t))); // finally: invoke downloading QMetaObject::invokeMethod(&downloadManager, "checkForAllDone", Qt::QueuedConnection); }
void FvUpdater::startDownloadFeed(QUrl url) { m_xml.clear(); // Check SSL Fingerprint if required if(url.scheme()=="https" && !m_requiredSslFingerprint.isEmpty()) if( !checkSslFingerPrint(url) ) // check failed { qWarning() << "Update aborted."; return; } m_reply = m_qnam.get(QNetworkRequest(url)); connect(m_reply, SIGNAL(readyRead()), this, SLOT(httpFeedReadyRead())); connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(httpFeedUpdateDataReadProgress(qint64, qint64))); connect(m_reply, SIGNAL(finished()), this, SLOT(httpFeedDownloadFinished())); }
void QGitHubReleaseAPIPrivate::downloaded(const FileDownloader &fd) { QObject::connect(m_apiDownloader, SIGNAL(error(QString)), this, SLOT(fdError(QString))); QObject::connect(m_apiDownloader, SIGNAL(downloaded(FileDownloader)), this, SLOT(downloaded(FileDownloader))); QObject::connect(m_apiDownloader, SIGNAL(progress(qint64,qint64)), this, SLOT(downloadProgress(qint64,qint64))); m_jsonData = fd.downloadedData(); foreach(const FileDownloader::RAWHEADERPAIR &pair, fd.rawHeaderPairs()) { if(pair.first == "ETag") m_eTag = pair.second.mid(2); if(pair.first == "X-RateLimit-Reset") { m_rateLimitReset = QDateTime::fromTime_t(QString(pair.second).toUInt()); } if(pair.first == "X-RateLimit-Limit") m_rateLimit = QString(pair.second).toUInt(); if(pair.first == "X-RateLimit-Remaining") { m_rateLimitRemaining = QString(pair.second).toUInt(); } } QVariant va(parseJSon(m_jsonData, m_errorString)); if(m_errorString.isNull()) { if(m_singleEntryRequested) { m_vdata.append(va); } else if((m_vdata = va.toList()).isEmpty()) { m_errorString = va.toMap()["message"].toString(); emit error(m_errorString); return; } emit available(); } else { emit error(m_errorString); } }
void UBHttpGet::get(QUrl pUrl, QPointF pPos, QSize pSize, bool isBackground) { mPos = pPos; mSize = pSize; mIsBackground = isBackground; if (mReply) delete mReply; UBNetworkAccessManager * nam = UBNetworkAccessManager::defaultAccessManager(); mReply = nam->get(QNetworkRequest(pUrl)); //mReply deleted by this destructor mDownloadedBytes.clear(); connect(mReply, SIGNAL(finished()), this, SLOT(requestFinished())); connect(mReply, SIGNAL(readyRead()), this, SLOT(readyRead())); connect(mReply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(downloadProgressed(qint64, qint64))); }
void UINetworkRequest::prepareNetworkReply() { /* Create network-reply: */ m_pReply = new UINetworkReply(m_type, m_url, m_requestHeaders); AssertPtrReturnVoid(m_pReply.data()); { /* Prepare network-reply: */ connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(sltHandleNetworkReplyProgress(qint64, qint64))); connect(m_pReply, SIGNAL(finished()), this, SLOT(sltHandleNetworkReplyFinish())); /* Mark network-reply as running: */ m_fRunning = true; /* Notify common network-request listeners: */ emit sigStarted(m_uuid); /* Notify own network-request listeners: */ emit sigStarted(); } }