datasourcefactory.h

Go to the documentation of this file.

/* This file is part of the KDE project

   Copyright (C) 2008 Lukas Appelhans <l.appelhans@gmx.de>
   Copyright (C) 2009 Matthias Fuchs <mat69@gmx.net>

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
*/ 
#ifndef DATASOURCEFACTORY_H
#define DATASOURCEFACTORY_H

#include "kget_export.h"

#include "transferdatasource.h"
#include "job.h"

#include <kio/job.h>

#include <QtXml/QDomElement>

class BitSet;
class KioDownload;
class TransferDataSource;
class QTimer;
class Signature;
class Verifier;

namespace KIO
{
    class FileJob;
}

class KGET_EXPORT DataSourceFactory : public QObject
{
    Q_OBJECT

    public:
        explicit DataSourceFactory(QObject *parent, const KUrl &dest = KUrl(), KIO::filesize_t size = 0, KIO::fileoffset_t segSize = 512000);

        ~DataSourceFactory();

        Transfer::Capabilities capabilities() const {return m_capabilities;}

        void deinit();

        bool isValid() const;

        void start();
        void stop();
        KIO::filesize_t size() const {return m_size;}
        KIO::filesize_t downloadedSize() const {return m_downloadedSize;}
        ulong currentSpeed() const {return m_speed;}
        ulong percent() const {return m_percent;}

        KUrl dest() const {return m_dest;}

        int maxMirrorsUsed() const {return m_maxMirrorsUsed;}

        void setMaxMirrorsUsed(int maxMirrorsUsed) {m_maxMirrorsUsed = maxMirrorsUsed;}

        void addMirror(const KUrl &url, bool used, int numParalellConnections = 1);

        void addMirror(const KUrl &url, int numParalellConnections = 1);

        void removeMirror(const KUrl &url);

        void setMirrors(const QHash<KUrl, QPair<bool, int> > &mirrors);

        QHash<KUrl, QPair<bool, int> > mirrors() const;

        bool doDownload() const {return m_doDownload;}

        void setDoDownload(bool doDownload);

        bool setNewDestination(const KUrl &newDest);

        Job::Status status() const {return m_status;}

        bool downloadInitialized() const {return m_downloadInitialized;}

        void repair();

        Verifier *verifier();
        Signature *signature();

    Q_SIGNALS:
        void capabilitiesChanged();
        void dataSourceFactoryChange(Transfer::ChangesFlags change);
        void log(const QString &message, Transfer::LogLevel logLevel);

    public slots:
        void save(const QDomElement &element);
        void load(const QDomElement *e);

    private slots:
        void slotUpdateCapabilities();

        void slotRemovedFile();

        void findFileSize();

        void slotFoundFileSize(TransferDataSource *source, KIO::filesize_t fileSize, const QPair<int,int> &segmentRange);

        void assignSegments(TransferDataSource *source);
        void brokenSegments(TransferDataSource *source, const QPair<int, int> &segmentRange);
        void finishedSegment(TransferDataSource *source, int segmentNumber, bool connectionFinished = true);

        void broken(TransferDataSource *source, TransferDataSource::Error error);
        void slotFreeSegments(TransferDataSource *source, QPair<int, int> segmentRange);
        void slotWriteData(KIO::fileoffset_t offset, const QByteArray &data, bool &worked);
        void slotOffset(KIO::Job *job, KIO::filesize_t offset);
        void slotDataWritten(KIO::Job *job, KIO::filesize_t offset);
        void slotPercent(KJob *job, ulong percent);
        void open(KIO::Job *job);
        void speedChanged();
        void startMove();
        void slotPutJobDestroyed(QObject *job);
        void newDestResult(KJob *job);

        void slotRepair(const QList<KIO::fileoffset_t> &offsets, KIO::filesize_t length);

        void slotFinishedDownload(TransferDataSource *source, KIO::filesize_t size);
        
        void slotUrlChanged(const KUrl &, const KUrl &);

    private:
        void addMirror(const KUrl &url, bool used, int numParalellConnections, bool usedDefined);

        bool assignNeeded() const;

        bool checkLocalFile();

        void init();
        void killPutJob();
        void changeStatus(Job::Status status);

    private:
        Transfer::Capabilities m_capabilities;
        KUrl m_dest;
        KUrl m_newDest;
        KIO::filesize_t m_size;
        KIO::filesize_t m_downloadedSize;
        QList<KIO::filesize_t> m_prevDownloadedSizes;
        KIO::fileoffset_t m_segSize;
        ulong m_speed;
        ulong m_percent;

        QHash<KIO::fileoffset_t, QByteArray> m_cache;

        KIO::filesize_t m_tempOffset;
        QByteArray m_tempData;

        BitSet *m_startedChunks;
        BitSet *m_finishedChunks;
        KIO::FileJob* m_putJob;
        bool m_doDownload;
        bool m_open;
        bool m_blocked;
        bool m_startTried;
        bool m_findFilesizeTried;

        bool m_assignTried;
        bool m_movingFile;

        bool m_finished;

        bool m_downloadInitialized;

        bool m_sizeInitiallyDefined;

        bool m_sizeFoundOnFinish;

        int m_maxMirrorsUsed;
        QHash<KUrl, TransferDataSource*> m_sources;
        QList<KUrl> m_unusedUrls;
        QList<int> m_unusedConnections;
        QTimer *m_speedTimer;
        Job::Status m_status;
        Job::Status m_statusBeforeMove;

        Verifier *m_verifier;
        Signature *m_signature;
};

#endif