Un updater avec Qt : le téléchargement de fichiers

Les classes qui seront présentées ici ont été introduites avec Qt 4.4.

QNetworkAccessManager est devenue, avec Qt 4.4, la classe de référence pour gérer le réseau : elle contient la configuration générale, les propriétés pour chaque requête, elle gère le proxy et le cache, et peut être utilisée pour l'entièreté des protocoles supportés par Qt (HTTP, HTTPS, FTP...).

Dès qu'un objet QNetworkAccessManager a été créé, il peut être utilisé par l'application pour envoyer des requêtes sur le réseau. Une série de fonctions est disponible pour s'occuper de la requête et des données optionnelles.

Chaque requête crée un nouvel objet QNetworkRequest. Cet objet contient l'URL de la ressource vers laquelle il pointe. Cette requête ne contient strictement aucune donnée : elle représente les entêtes de chaque requête.

Les données, quant à elles, sont transmises par l'objet QNetworkReply.

Voici un petit exemple pour synthétiser toutes ces informations.

QNetworkAccessManager * manager = new QNetworkAccessManager();

QUrl url ("http://qt.developpez.com");

QNetworkReply * reply = manager->get(url);

manager enverra le signal finished (QNetworkReply *) dès que le téléchargement sera terminé.

I-A. Gestion des proxies▲

QNetworkProxy proxy;
proxy.setType(QNetworkProxy::Socks5Proxy);
proxy.setHostName("proxy.exemple.com");
proxy.setPort(1080);
proxy.setUser("username");
proxy.setPassword("password");

QNetworkProxy proxy (
                QNetworkProxy::Socks5Proxy,
                "proxy.exemple.com",
                1080,
                "username"
                "password"
                    );

enum ProxyType { NoProxy, DefaultProxy, Socks5Proxy, HttpProxy,
                 HttpCachingProxy, FtpCachingProxy              }

I-B. Requêtes POST et PUT▲

QNetworkReply * QNetworkAccessManager::post ( const QNetworkRequest & request,       QIODevice  * data );
QNetworkReply * QNetworkAccessManager::post ( const QNetworkRequest & request, const QByteArray & data );

QNetworkReply * QNetworkAccessManager::put  ( const QNetworkRequest & request,       QIODevice  * data );
QNetworkReply * QNetworkAccessManager::put  ( const QNetworkRequest & request, const QByteArray & data );

I-C. Requêtes HEAD et GET▲

QNetworkReply * get  ( const QNetworkRequest & request ) 
QNetworkReply * head ( const QNetworkRequest & request )

I-D. En cas d'erreur▲

QFile fait partie de la grande famille des dérivés de QIODevice.

Cette classe est une couche d'abstraction pour toutes les classes d'E/S de Qt. Ceci permet d'utiliser cette classe pour désigner toutes les méthodes d'E/S qui coexistent dans Qt : fichiers, buffers, sockets, processus, ou bien QNetworkReply.

Un QFile représente un fichier en local. Pour en construire un, la marche à suivre est simple. Elle est détaillée dans cet exemple.

QFile file("in.txt");

if (! file.open(QIODevice::ReadOnly))
    return;

int i = 1;

while (!file.atEnd())
{
    QByteArray line = file.readLine();
    qDebug() << "Ligne " << i << " : " << line;
    ++i;
}

On initialise un QFile en passant au constructeur le nom du fichier à ouvrir. Ensuite, on donne le mode d'ouverture. Puis, on traite le fichier.

Voici les différents modes de lecture autorisés. Ils peuvent être facilement associés avec le pipe (|).

• QIODevice::NotOpen
• QIODevice::ReadOnly
• QIODevice::WriteOnly
• QIODevice::ReadWrite
• QIODevice::Append
• QIODevice::Truncate
• QIODevice::Text
• QIODevice::Unbuffered

Voici un nouvel exemple qui montre la combinaison de plusieurs modes.

QFile file("in.txt");

if (! file.open(QIODevice::ReadOnly | QIODevice::Text))
    return;

while (!file.atEnd())
{
    QByteArray line = file.readLine();
    qDebug() << "Ligne " << i << " : " << line;
    ++i;
}

Pour écrire dans un fichier, rien de plus simple. On peut utiliser un QByteArray ou bien un const char *.

file.write ("Du texte\n");

QByteArray text = new QByteArray ("Du texte");
file.write (text);

Les QByteArray sont indispensables pour pouvoir utiliser les QIODevice. En effet, pour lire des données d'un QIODevice, les fonctions fournies retournent des QByteArray ou des types de la STL. Même chose pour l'écriture.

Voici les fonctions employées pour la lecture et l'écriture dans des QIODevice.

• qint64read(char * data, qint64 maxSize )
• QByteArrayread(qint64 maxSize )
• QByteArrayreadAll ()
• qint64readLine(char * data, qint64 maxSize )
• QByteArrayreadLine(qint64 maxSize = 0 )

• qint64write(const char * data, qint64 maxSize )
• qint64write(const char * data )
• qint64write(const QByteArray & byteArray )

QFile dérive de QIODevice, tout comme QNetworkReply : en tant que tels, ils ont tous deux une série de fonctions en commun. Par exemple, toutes les méthodes de lecture et d'écriture présentées ci-dessus.

Un petit exemple : comment écrire le contenu d'une réponse dans un fichier ?

QFile * file = new QFile ( QString("fichier") );
file->open(QIODevice::ReadOnly);

QNetworkAccessManager manager (this);

QNetworkRequest request ("http://qt.developpez.com/index.php");
QNetworkReply * reply = manager.get(request);

file->write( reply->readAll() );

Dans cet exemple, il est peu probable que des données soient écrites sur le disque dur. En effet, on commence à les écrire avant de savoir si elles sont disponibles. Pour cela, le signal finished() est proposé par QNetworkReply. La dernière ligne de code ira dans le slot connecté à ce signal.

L'inverse est aussi possible.

QFile * file = new QFile ( QString("fichier") );
file->open(QIODevice::WriteOnly);

QNetworkAccessManager manager (this);

QNetworkRequest request ("http://qt.developpez.com/index.php");

QNetworkReply * reply = manager.put(request, file->readAll() );

III-A. La philosophie▲

III-B. L'implémentation▲

#include <QtGui/QApplication>
#include <QtGui/QPushButton>

#include <updaterHandler.hpp>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    QPushButton bouton("Mettre à jour");

    updaterHandler handler = new updaterHandler ();

    QObject::connect (& bouton , SIGNAL( clicked()      ),
                      & handler, SLOT  ( launchUpdate() )  );

    bouton.show();

    return a.exec();
}

class updaterHandler : public QObject
{
    Q_OBJECT

public:
    updaterHandler(QObject * parent = 0);
    ~updaterHandler();

public slots:
    void launchUpdate();
    void writeUpdate();

private:
    QNetworkAccessManager manager;
    QNetworkRequest       request;
    QUrl                  url;
    QFile                 file;
    QNetworkReply       * reply;
};

updaterHandler::updaterHandler(QObject *parent)
    : QObject(parent)
{
    QNetworkAccessManager manager (this);
    QUrl url ("http://qt.developpez.com/");

    QFile * file = new QFile ( QString("index.php"), this );
    file->open(QIODevice::WriteOnly);

    QObject::connect ( reply, SIGNAL ( finished()    ),
                       this , SLOT   ( writeUpdate() )  );
}

updaterHandler::~updaterHandler() {}

void updaterHandler::launchUpdate()
{
    QNetworkRequest request (this->url);
    QNetworkReply * reply = manager.get(request);
}

void updaterHandler::writeUpdate()
{
    this->file->write(reply->readAll());
}

Le code source est disponible.

Un tout grand merci à yan, Alp et à superjaja pour leurs encouragements et conseils lors de la rédaction de cet article !