C++ QNetworkRequest函数代码示例

        progressBar->setValue(40);
        progressLabel->setText(tr("Upload ride... Sending"));

        networkMgr.post( request, out.toAscii());
    } else {
        QByteArray data;
        QUrl params;
        TcxFileReader reader;

        params.addQueryItem("token", token);
        params.addQueryItem("type", "tcx");
        params.addQueryItem("data", reader.toByteArray(mainWindow, ride->ride(), altitudeChk->isChecked(), powerChk->isChecked(), heartrateChk->isChecked(), cadenceChk->isChecked()));
        data = params.encodedQuery();

        QUrl url = QUrl(STRAVA_URL2 + "/upload");
        QNetworkRequest request = QNetworkRequest(url);
        request.setHeader(QNetworkRequest::ContentTypeHeader,"application/x-www-form-urlencoded");

        progressBar->setValue(40);
        progressLabel->setText(tr("Upload ride... Sending"));

        networkMgr.post( request, data);
    }

    //qDebug() << out;

    eventLoop.exec();
}

void
StravaUploadDialog::requestUploadFinished(QNetworkReply *reply)

void PlaylistModel::fetchFromUrl()
{
    m_manager->get(QNetworkRequest(QUrl("http://"+m_remoteUrl+"/requests/playlist.xml").toString()));
}

void FMList::init(){
    this->loaded_count=0;
    this->request=QNetworkRequest(QUrl("http://fm.renren.com/fm/home"));
    QObject::connect(this,SIGNAL(addFM(FMInfo*)),this->view,SLOT(addItem(FMInfo*)),Qt::QueuedConnection);
}

QNetworkReply* QtWebKitNetworkManager::createRequest(QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice *outgoingData)
{
	if (request.url() == m_formRequestUrl)
	{
		m_formRequestUrl = QUrl();

		m_widget->openFormRequest(request.url(), operation, outgoingData);

		return QNetworkAccessManager::createRequest(QNetworkAccessManager::GetOperation, QNetworkRequest());
	}

	const QString host = request.url().host();

	if (!m_widget->isNavigating() && ContentBlockingManager::isUrlBlocked(m_widget->getContentBlockingProfiles(), request, m_widget->getUrl()))
	{
		Console::addMessage(QCoreApplication::translate("main", "Blocked request"), Otter::NetworkMessageCategory, LogMessageLevel, request.url().toString());

		QUrl url = QUrl();
		url.setScheme(QLatin1String("http"));

		if (m_blockedRequests.contains(host))
		{
			++m_blockedRequests[host];
		}
		else
		{
			m_blockedRequests[host] = 1;
		}

		return QNetworkAccessManager::createRequest(QNetworkAccessManager::GetOperation, QNetworkRequest(url));
	}

	++m_startedRequests;

	if (operation == GetOperation && request.url().isLocalFile() && QFileInfo(request.url().toLocalFile()).isDir())
	{
		return new LocalListingNetworkReply(this, request);
	}

	QNetworkRequest mutableRequest(request);

	if (!m_canSendReferrer)
	{
		mutableRequest.setRawHeader(QStringLiteral("Referer").toLatin1(), QByteArray());
	}

	if (operation == PostOperation && mutableRequest.header(QNetworkRequest::ContentTypeHeader).isNull())
	{
		mutableRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/x-www-form-urlencoded"));
	}

	if (NetworkManagerFactory::isWorkingOffline())
	{
		mutableRequest.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysCache);
	}
	else if (m_doNotTrackPolicy != NetworkManagerFactory::SkipTrackPolicy)
	{
		mutableRequest.setRawHeader(QByteArray("DNT"), QByteArray((m_doNotTrackPolicy == NetworkManagerFactory::DoNotAllowToTrackPolicy) ? "1" : "0"));
	}

	mutableRequest.setRawHeader(QStringLiteral("Accept-Language").toLatin1(), (m_acceptLanguage.isEmpty() ? NetworkManagerFactory::getAcceptLanguage().toLatin1() : m_acceptLanguage.toLatin1()));
	mutableRequest.setHeader(QNetworkRequest::UserAgentHeader, m_userAgent);

	emit messageChanged(tr("Sending request to %1…").arg(host));

	QNetworkReply *reply = QNetworkAccessManager::createRequest(operation, mutableRequest, outgoingData);

	if (!m_baseReply)
	{
		m_baseReply = reply;
	}

	if (m_isSecure >= 0)
	{
		const QString scheme = reply->url().scheme();

		if (scheme == QLatin1String("https"))
		{
			m_isSecure = 1;
		}
		else if (scheme == QLatin1String("http"))
		{
			m_isSecure = -1;
		}
	}

	m_replies[reply] = qMakePair(0, false);

	connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(downloadProgress(qint64,qint64)));

	if (m_updateTimer == 0)
	{
		m_updateTimer = startTimer(500);
	}

	return reply;
}

QPlaceSearchReply *QPlaceManagerEngineOsm::search(const QPlaceSearchRequest &request)
{
    bool unsupported = false;

    // Only public visibility supported
    unsupported |= request.visibilityScope() != QLocation::UnspecifiedVisibility &&
                   request.visibilityScope() != QLocation::PublicVisibility;
    unsupported |= request.searchTerm().isEmpty() && request.categories().isEmpty();

    if (unsupported)
        return QPlaceManagerEngine::search(request);

    QUrlQuery queryItems;

    queryItems.addQueryItem(QStringLiteral("format"), QStringLiteral("jsonv2"));

    //queryItems.addQueryItem(QStringLiteral("accept-language"), QStringLiteral("en"));

    QGeoRectangle boundingBox;
    QGeoShape searchArea = request.searchArea();
    switch (searchArea.type()) {
    case QGeoShape::CircleType: {
        QGeoCircle c(searchArea);
        qreal radius = c.radius();
        if (radius < 0)
            radius = 50000;

        boundingBox = QGeoRectangle(c.center().atDistanceAndAzimuth(radius, -45),
                                    c.center().atDistanceAndAzimuth(radius, 135));
        break;
    }
    case QGeoShape::RectangleType:
        boundingBox = searchArea;
        break;
    default:
        ;
    }

    if (!boundingBox.isEmpty()) {
        queryItems.addQueryItem(QStringLiteral("bounded"), QStringLiteral("1"));
        QString coordinates;
        coordinates = QString::number(boundingBox.topLeft().longitude()) + QLatin1Char(',') +
                      QString::number(boundingBox.topLeft().latitude()) + QLatin1Char(',') +
                      QString::number(boundingBox.bottomRight().longitude()) + QLatin1Char(',') +
                      QString::number(boundingBox.bottomRight().latitude());
        queryItems.addQueryItem(QStringLiteral("viewbox"), coordinates);
    }

    QStringList queryParts;
    if (!request.searchTerm().isEmpty())
        queryParts.append(request.searchTerm());

    foreach (const QPlaceCategory &category, request.categories()) {
        QString id = category.categoryId();
        int index = id.indexOf(QLatin1Char('='));
        if (index != -1)
            id = id.mid(index+1);
        queryParts.append(QLatin1Char('[') + id + QLatin1Char(']'));
    }

    queryItems.addQueryItem(QStringLiteral("q"), queryParts.join(QLatin1Char('+')));

    QVariantMap parameters = request.searchContext().toMap();

    QStringList placeIds = parameters.value(QStringLiteral("ExcludePlaceIds")).toStringList();
    if (!placeIds.isEmpty())
        queryItems.addQueryItem(QStringLiteral("exclude_place_ids"), placeIds.join(QLatin1Char(',')));

    queryItems.addQueryItem(QStringLiteral("addressdetails"), QStringLiteral("1"));

    QUrl requestUrl(m_urlPrefix);
    requestUrl.setQuery(queryItems);

    QNetworkReply *networkReply = m_networkManager->get(QNetworkRequest(requestUrl));

    QPlaceSearchReplyOsm *reply = new QPlaceSearchReplyOsm(request, networkReply, this);
    connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
    connect(reply, SIGNAL(error(QPlaceReply::Error,QString)),
            this, SLOT(replyError(QPlaceReply::Error,QString)));

    return reply;
}

void NetworkComm::sendGetRequest(QString s){
    QUrl url(s);
    rply = nam->get(QNetworkRequest(url));
    qDebug()<<"get request to "<<s;
}

// Callback from fetchIcon
void
MainWindow::iconDownloaded()
{
    QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
    QString savePath = reply->request().attribute(QNetworkRequest::User).toString();
    int wasRedirected = reply->request().attribute((QNetworkRequest::Attribute)(QNetworkRequest::User+1)).toInt();
    QString username = reply->request().attribute((QNetworkRequest::Attribute)(QNetworkRequest::User+2)).toString();
    QString password = reply->request().attribute((QNetworkRequest::Attribute)(QNetworkRequest::User+3)).toString();

    QVariant redirect = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);

    if (!redirect.toUrl().isEmpty() && !wasRedirected)
    {
        qDebug() << "Was redirected to " << redirect.toUrl();
        reply->deleteLater();
        QUrl redir = redirect.toUrl();
        if (!username.isEmpty())
        {
            redir.setUserName(username);
            redir.setPassword(password);
        }
        QNetworkRequest req = QNetworkRequest(redir);
        req.setAttribute(QNetworkRequest::User, QVariant(savePath));
        req.setAttribute((QNetworkRequest::Attribute)(QNetworkRequest::User+1), QVariant(1));
        QNetworkReply *rep = pManager->get(req);
        connect(rep, SIGNAL(finished()),
                this, SLOT(iconDownloaded()));
        return;
    }

    qDebug() << "Icon downloaded";
    if (reply->error())
    {
        reply->close();
        qDebug() << "Couldn't get icon";
        fetchHTMLIcon(reply->url().toString(), savePath);
        return;
    }

    QByteArray logoData = reply->readAll();
    // The favicon can be in various formats, so convert it to something
    // we know we can safely display
    QBuffer logoBuffer(&logoData);
    logoBuffer.open(QIODevice::ReadOnly);
    QImageReader reader(&logoBuffer);
    QSize iconSize(16, 16);
    if(reader.canRead())
    {
        while((reader.imageCount() > 1) && (reader.currentImageRect() != QRect(0, 0, 16, 16)))
        {
            if (!reader.jumpToNextImage())
                   break;
        }

        reader.setScaledSize(iconSize);
        const QImage icon = reader.read();
        if (icon.format() == QImage::Format_Invalid)
        {
            fetchHTMLIcon(reply->url().toString(), savePath);
        }
        else
        {
            icon.save(savePath, "PNG");
            QFileInfo info(savePath);
            int tabIndex = compareTabName(info.baseName());
            if (tabIndex != -1)
                ui->trackerTab->setTabIcon(tabIndex, QIcon(QPixmap::fromImage(icon)));
        }
    }
    else
    {
        qDebug() << "Invalid image";
        fetchHTMLIcon(reply->url().toString(), savePath);
    }

    logoBuffer.close();
    reply->close();
}

void UpdateInfoDialog::CheckUpdate()
{
    int os_num = 0;

#if defined(Q_OS_WIN32)
    if(QT_POINTER_SIZE == 4){
        os_num = OS_NUM_WIN_32;
    }else{
        os_num = OS_NUM_WIN_64;
    }
#elif defined(Q_OS_MAC)
    if(QT_POINTER_SIZE == 4){
        os_num = OS_NUM_MAC_32;
    }else{
        os_num = OS_NUM_MAC_64;
    }
#else
    if(QT_POINTER_SIZE == 4){
        os_num = OS_NUM_LINUX_32;
    }else{
        os_num = OS_NUM_LINUX_64;
    }
#endif

//    qDebug() << "check update";
    QNetworkAccessManager *net = new QNetworkAccessManager(this);
    connect(net, &QNetworkAccessManager::finished, [this](QNetworkReply *reply) {
        if(reply->error() == QNetworkReply::NoError){

            QJsonDocument json = QJsonDocument::fromJson(reply->readAll());
            bool exist = json.object().value(KEY_UPDATE_EXIST).toBool();

//            qDebug() << "download " << json.object().value(KEY_DOWNLOAD_URL).toString();
//            qDebug() << "web " << json.object().value(KEY_WEBPAGE_URL).toString();
//            qDebug() << "exist " << exist;
//            qDebug() << "ver " << json.object().value(KEY_NEW_VERSION).toString();
//            qDebug() << "ver code " << json.object().value(KEY_NEW_VERSION_CODE).toDouble() << "<=" << KANMEMO_VERSION_CODE;

            //バージョンコード
            m_newVersionCode = static_cast<int>(json.object().value(KEY_NEW_VERSION_CODE).toDouble());
            if(isHide(m_newVersionCode) && !m_force){
                m_force = true; //1度通ったらはユーザー操作なので強制表示
                return; //非表示
            }

            if(exist){
                //ダイアログ表示
                //Download
                QString download_url = json.object().value(KEY_DOWNLOAD_URL).toString();
                QStringList url_list = download_url.split("|");
                ui->downloadUrlLabel1->setText(QString("<a href='%1'>%1</a>").arg(url_list[0]));
                if(url_list.count() > 1){
                    ui->downloadUrlLabel2->setText(QString("<a href='%1'>%1</a>").arg(url_list[1]));
                }else{
                    ui->downloadUrlLabel2->clear();
                }
                //WebPage
                ui->webpageUrlLabel->setText(QString("<a href='%1'>%1</a>").arg(json.object().value(KEY_WEBPAGE_URL).toString()));
                //Version Number
                ui->versionNumberLabel->setText(json.object().value(KEY_NEW_VERSION).toString());
                //message
                ui->messageTextEdit->setPlainText(json.object().value(KEY_MESSAGE).toString());
                //必ずチェックを外す
                ui->hideNextUpdatecheckBox->setChecked(false);

                show();
            }else if(m_force){
                //更新なし
                QMessageBox::information(this
                                     , tr("Kan Memo")
                                     , tr("There was no update.")
                                     , QMessageBox::Yes);
            }

            m_force = true; //1度通ったらはユーザー操作なので強制表示
        }
    });
    //プロキシ
    if(m_settings != NULL){
        QNetworkProxy *proxy = new QNetworkProxy();
        bool enable = m_settings->value(SETTING_GENERAL_PROXY_ENABLE, false).toBool();
        QString host = m_settings->value(SETTING_GENERAL_PROXY_HOST).toString();
        if(host.length() > 0 && enable){
            proxy->setType(QNetworkProxy::HttpProxy);
            proxy->setHostName(host);
            proxy->setPort(m_settings->value(SETTING_GENERAL_PROXY_PORT, 8888).toInt());

            net->setProxy(*proxy);
        }else{
            net->setProxy(QNetworkProxy::NoProxy);
        }
    }
    //アクセス開始
    net->get(QNetworkRequest(CHECK_UPDATE_URL
                             .arg(KANMEMO_VERSION)
                             .arg(KANMEMO_VERSION_CODE)
                             .arg(os_num)
                             .arg(QLocale::system().name())));
}

void Updater::startDownloadingUpdateInfo(const QUrl &url)
{
    QNetworkReply *reply = mApp->networkManager()->get(QNetworkRequest(QUrl(url)));

    connect(reply, SIGNAL(finished()), this, SLOT(downCompleted()));
}

QNetworkReply* ElisaNetworkService::makeRequest(QString uri)
{
    uri = BASE_URI + uri;
    return mNetworkManager->get(QNetworkRequest(QUrl(uri)));
}

void UltimateLyricsProvider::LyricsFetched() {
  QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
  if (!reply) {
    url_hop_ = false;
    return;
  }

  int id = requests_.take(reply);
  reply->deleteLater();

  if (reply->error() != QNetworkReply::NoError) {
    url_hop_ = false;
    emit Finished(id);
    return;
  }

  // Handle redirects
  QVariant redirect_target = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
  if (redirect_target.isValid()) {
    if (redirect_count_ >= kRedirectLimit) {
      url_hop_ = false;
      emit Finished(id);
      return;
    }

    QUrl target = redirect_target.toUrl();
    if (target.scheme().isEmpty() || target.host().isEmpty()) {
      QString path = target.path();
      target = reply->url();
      target.setPath(path);
    }

    redirect_count_ ++;
    QNetworkReply* reply = network_->get(QNetworkRequest(target));
    requests_[reply] = id;
    connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
    return;
  }

  const QTextCodec* codec = QTextCodec::codecForName(charset_.toAscii().constData());
  const QString original_content = codec->toUnicode(reply->readAll());
  QString lyrics;

  // Check for invalid indicators
  foreach (const QString& indicator, invalid_indicators_) {
    if (original_content.contains(indicator)) {
      qLog(Debug) << "Found invalid indicator" << indicator;
      url_hop_ = false;
      emit Finished(id);
      return;
    }
  }

  if (!url_hop_) {
    // Apply extract rules
    foreach (const Rule& rule, extract_rules_) {
      // Modify the rule for this request's metadata
      Rule rule_copy(rule);
      for (Rule::iterator it = rule_copy.begin() ; it != rule_copy.end() ; ++it) {
        ReplaceFields(metadata_, &it->first);
      }

      QString content = original_content;
      if (ApplyExtractRule(rule_copy, &content)) {
        url_hop_ = true;
        QUrl url(content);
        qLog(Debug) << "Next url hop: " << url;
        QNetworkReply* reply = network_->get(QNetworkRequest(url));
        requests_[reply] = id;
        connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
        return;
      }

      // Apply exclude rules
      foreach (const Rule& rule, exclude_rules_) {
        ApplyExcludeRule(rule, &lyrics);
      }

//.........这里部分代码省略.........
    //-----------------解析网页，获得数据--------------------

    emit this->updateState(QString("update:request text from ")+this->currentUrl.url());

    int initCount=this->data.size();
    if(this->analysisData.isEmpty())
    {
        this->getData(text,this->data);
    }
    else
    {
        QRegExp reg=this->analysisData;
        int pos = 0;
        int count=0;
        while ((pos = reg.indexIn(text, pos)) != -1)
        {
            QString line=reg.cap(0);

            if(!line.isEmpty())
            {
                this->data.insert(line,0);
            }
            count++;
            pos += reg.matchedLength();
        }
    }
    if(data.size()<=initCount)
    {
        emit getDataError(QString("none data capture."));
        if(analysisDataError())
        {
            return;
        }
    }

    emit this->updateState(QString("update:get data ")+QString::number(data.size()-initCount));


    //-----------------解析网页，获得下一个网址---------------
    this->allUrl.insert(this->currentUrl.url(),-1);
    if(this->analysisNextUrl.isEmpty())
    {
        this->getNextUrl(text,this->currentUrl);
    }
    else
    {
        QRegExp reg=this->analysisNextUrl;
        int pos = 0;
        if((pos = reg.indexIn(text, pos)) != -1)
        {
            QString line=reg.cap(0);
            if(!line.isEmpty())
            {
                this->currentUrl=this->captureToUrl(line,this->currentUrl);
            }
            else
            {
                this->currentUrl=QUrl();
            }

        }
    }

    if(currentUrl.isEmpty())
    {
        emit getDataError(QString("none data capture."));
        if(analysisDataError())
        {
            return;
        }
    }

    emit this->updateState(QString("update:get next url ")+this->currentUrl.url());

    //-----------------验证终止-----------------------------
    if(finishWork(text))
    {
        emit this->updateState(QString("update:finish at finishWork()"));
        emit workFinish(this->data.keys());
        return;
        this->save();
    }
    if(allUrl.find(this->currentUrl.url())!=allUrl.end())
    {
        emit this->updateState(QString("update:finish : same url"));
        emit workFinish(this->data.keys());
        return;
        this->save();
    }
    if(this->currentUrl.isEmpty())
    {
        emit this->updateState(QString("update:finish empty url"));
        this->save();
        return;
    }
    //----------------开始下一个网页-------------------------
    emit this->updateState(QString("update:request url ")+this->currentUrl.url());

    this->manager->get(QNetworkRequest(this->currentUrl));
}

void
StravaUploadDialog::requestUpload()
{
    progressLabel->setText(tr("Upload ride..."));
    progressBar->setValue(10);

    QEventLoop eventLoop;
    QNetworkAccessManager networkMgr;

    int prevSecs = 0;
    long diffSecs = 0;

    int year = ride->fileName.left(4).toInt();
    int month = ride->fileName.mid(5,2).toInt();
    int day = ride->fileName.mid(8,2).toInt();
    int hour = ride->fileName.mid(11,2).toInt();
    int minute = ride->fileName.mid(14,2).toInt();;
    int second = ride->fileName.mid(17,2).toInt();;

    QDate rideDate = QDate(year, month, day);
    QTime rideTime = QTime(hour, minute, second);
    QDateTime rideDateTime = QDateTime(rideDate, rideTime);

    connect(&networkMgr, SIGNAL(finished(QNetworkReply*)), this, SLOT(requestUploadFinished(QNetworkReply*)));
    connect(&networkMgr, SIGNAL(finished(QNetworkReply *)), &eventLoop, SLOT(quit()));

    bool json = false;

    if (json) {
        QString out;

        QVector<RideFilePoint*> vectorPoints = ride->ride()->dataPoints();
        int totalSize = vectorPoints.size();

        int size = 0;

        out += "{\"token\": \"" + token + "\",\"data\":[";
        foreach (const RideFilePoint *point, ride->ride()->dataPoints())
        {
            size++;

            if (point->secs == 0.0)
                continue;

            diffSecs = point->secs - prevSecs;
            prevSecs = point->secs;
            rideDateTime = rideDateTime.addSecs(diffSecs);

            out += "[\"";
            out += rideDateTime.toUTC().toString(Qt::ISODate);
            out += "\",";
            out += QString("%1").arg(point->lat,0,'f',GPS_COORD_TO_STRING);
            out += ",";
            out += QString("%1").arg(point->lon,0,'f',GPS_COORD_TO_STRING);

            if (altitudeChk->isChecked()) {
                out += ",";
                out += QString("%1").arg(point->alt);

            }
            if (powerChk->isChecked()) {
                out += ",";
                out += QString("%1").arg(point->watts);
            }
            if (altitudeChk->isChecked()) {
                out += ",";
                out += QString("%1").arg(point->cad);
            }
            if (heartrateChk->isChecked()) {
                out += ",";
                out += QString("%1").arg(point->hr);
            }
            out += "]";
            if(totalSize == size)
                out += "],";
           else
               out += ",";
        }
        out += "\"type\": \"json\", ";
        out += "\"data_fields\": \[\"time\", \"latitude\", \"longitude\"";

        if (altitudeChk->isChecked())
            out += ", \"elevation\"";
        if (powerChk->isChecked())
            out += ", \"watts\"";
        if (cadenceChk->isChecked())
            out += ", \"cadence\"";
        if (heartrateChk->isChecked())
            out += ", \"heartrate\"";
        out += "]}";

        QUrl url = QUrl(STRAVA_URL2 + "/upload");
        QNetworkRequest request = QNetworkRequest(url);
        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

        progressBar->setValue(40);
        progressLabel->setText(tr("Upload ride... Sending"));

        networkMgr.post( request, out.toAscii());
    } else {

void imageLoad::load(QString url)
{
    //get data from url
    access->get(QNetworkRequest(url));
}

void QgsVersionInfo::checkVersion()
{
  QNetworkReply *reply = QgsNetworkAccessManager::instance()->get( QNetworkRequest( QUrl( QStringLiteral( "https://ubuntu.qgis.org/version.txt" ) ) ) );
  connect( reply, &QNetworkReply::finished, this, &QgsVersionInfo::versionReplyFinished );
}