Home · All Classes · Main Classes · Grouped Classes · Modules · Functions

torrentclient.h Example File
^{network/torrent/torrentclient.h}

    /****************************************************************************
    **
    ** Copyright (C) 2004-2006 Trolltech AS. All rights reserved.
    **
    ** This file is part of the documentation of the Qt Toolkit.
    **
    ** This file may be used under the terms of the GNU General Public
    ** License version 2.0 as published by the Free Software Foundation
    ** and appearing in the file LICENSE.GPL included in the packaging of
    ** this file.  Please review the following information to ensure GNU
    ** General Public Licensing requirements will be met:
    ** http://www.trolltech.com/products/qt/opensource.html
    **
    ** If you are unsure which license is appropriate for your use, please
    ** review the following information:
    ** http://www.trolltech.com/products/qt/licensing.html or contact the
    ** sales department at sales@trolltech.com.
    **
    ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
    ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
    **
    ****************************************************************************/

    #ifndef TORRENTCLIENT_H
    #define TORRENTCLIENT_H

    #include <QBitArray>
    #include <QHostAddress>

    class MetaInfo;
    class PeerWireClient;
    class TorrentClientPrivate;
    class TorrentPeer;
    class TorrentPiece;
    template<typename T> class QList;
    class QTimerEvent;

    class TorrentPeer {
    public:
        QHostAddress address;
        quint16 port;
        QString id;
        bool interesting;
        bool seed;
        uint lastVisited;
        uint connectStart;
        uint connectTime;
        QBitArray pieces;
        int numCompletedPieces;

        inline bool operator==(const TorrentPeer &other)
        {
            return port == other.port
                && address == other.address
                && id == other.id;
        }
    };

    class TorrentClient : public QObject
    {
        Q_OBJECT
    public:
        enum State {
            Idle,
            Paused,
            Stopping,
            Preparing,
            Searching,
            Connecting,
            WarmingUp,
            Downloading,
            Endgame,
            Seeding
        };
        enum Error {
            UnknownError,
            TorrentParseError,
            InvalidTrackerError,
            FileError,
            ServerError
        };

        TorrentClient(QObject *parent = 0);
        ~TorrentClient();

        bool setTorrent(const QString &fileName);
        bool setTorrent(const QByteArray &torrentData);
        MetaInfo metaInfo() const;

        void setMaxConnections(int connections);
        int maxConnections() const;

        void setDestinationFolder(const QString &directory);
        QString destinationFolder() const;

        void setDumpedState(const QByteArray &dumpedState);
        QByteArray dumpedState() const;

        // Progress and stats for download feedback.
        qint64 progress() const;
        void setDownloadedBytes(qint64 bytes);
        qint64 downloadedBytes() const;
        void setUploadedBytes(qint64 bytes);
        qint64 uploadedBytes() const;
        int connectedPeerCount() const;
        int seedCount() const;

        // Accessors for the tracker
        QByteArray peerId() const;
        QByteArray infoHash() const;
        quint16 serverPort() const;

        // State and error.
        State state() const;
        QString stateString() const;
        Error error() const;
        QString errorString() const;

    signals:
        void stateChanged(TorrentClient::State state);
        void error(TorrentClient::Error error);

        void downloadCompleted();
        void peerInfoUpdated();

        void dataSent(int uploadedBytes);
        void dataReceived(int downloadedBytes);
        void progressUpdated(int percentProgress);
        void downloadRateUpdated(int bytesPerSecond);
        void uploadRateUpdated(int bytesPerSecond);

        void stopped();

    public slots:
        void start();
        void stop();
        void setPaused(bool paused);
        void setupIncomingConnection(PeerWireClient *client);

    protected slots:
        void timerEvent(QTimerEvent *event);

    private slots:
        // File management
        void sendToPeer(int readId, int pieceIndex, int begin, const QByteArray &data);
        void fullVerificationDone();
        void pieceVerified(int pieceIndex, bool ok);
        void handleFileError();

        // Connection handling
        void connectToPeers();
        QList<TorrentPeer *> weighedFreePeers() const;
        void setupOutgoingConnection();
        void initializeConnection(PeerWireClient *client);
        void removeClient();
        void peerPiecesAvailable(const QBitArray &pieces);
        void peerRequestsBlock(int pieceIndex, int begin, int length);
        void blockReceived(int pieceIndex, int begin, const QByteArray &data);
        void peerWireBytesWritten(qint64 bytes);
        void peerWireBytesReceived(qint64 bytes);
        int blocksLeftForPiece(const TorrentPiece *piece) const;

        // Scheduling
        void scheduleUploads();
        void scheduleDownloads();
        void schedulePieceForClient(PeerWireClient *client);
        void requestMore(PeerWireClient *client);
        int requestBlocks(PeerWireClient *client, TorrentPiece *piece, int maxBlocks);
        void peerChoked();
        void peerUnchoked();

        // Tracker handling
        void addToPeerList(const QList<TorrentPeer> &peerList);
        void trackerStopped();

        // Progress
        void updateProgress(int progress = -1);

    private:
        TorrentClientPrivate *d;
        friend class TorrentClientPrivate;
    };

    #endif