QXmppTransferManager.h

// SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
//
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef QXMPPTRANSFERMANAGER_H
#define QXMPPTRANSFERMANAGER_H
 
#include "QXmppClientExtension.h"
 
#include <QDateTime>
#include <QSharedData>
#include <QUrl>
#include <QVariant>
 
class QTcpSocket;
class QXmppByteStreamIq;
class QXmppIbbCloseIq;
class QXmppIbbDataIq;
class QXmppIbbOpenIq;
class QXmppIq;
class QXmppStreamInitiationIq;
class QXmppTransferFileInfoPrivate;
class QXmppTransferJobPrivate;
class QXmppTransferManager;
class QXmppTransferManagerPrivate;
 
class QXMPP_EXPORT QXmppTransferFileInfo
{
public:
    QXmppTransferFileInfo();
    QXmppTransferFileInfo(const QXmppTransferFileInfo &other);
    ~QXmppTransferFileInfo();
 
    QDateTime date() const;
    void setDate(const QDateTime &date);
 
    QByteArray hash() const;
    void setHash(const QByteArray &hash);
 
    QString name() const;
    void setName(const QString &name);
 
    QString description() const;
    void setDescription(const QString &description);
 
    qint64 size() const;
    void setSize(qint64 size);
 
    bool isNull() const;
    QXmppTransferFileInfo &operator=(const QXmppTransferFileInfo &other);
    bool operator==(const QXmppTransferFileInfo &other) const;

    static constexpr std::tuple XmlTag = { u"file", QXmpp::Private::ns_stream_initiation_file_transfer };
    void parse(const QDomElement &element);
    void toXml(QXmlStreamWriter *writer) const;
 
private:
    QSharedDataPointer<QXmppTransferFileInfoPrivate> d;
};
 
class QXMPP_EXPORT QXmppTransferJob : public QXmppLoggable
{
    Q_OBJECT
    Q_FLAGS(Method Methods)
    Q_PROPERTY(Direction direction READ direction CONSTANT)
    Q_PROPERTY(QUrl localFileUrl READ localFileUrl WRITE setLocalFileUrl NOTIFY localFileUrlChanged)
    Q_PROPERTY(QString jid READ jid CONSTANT)
    Q_PROPERTY(Method method READ method CONSTANT)
    Q_PROPERTY(State state READ state NOTIFY stateChanged)

    Q_PROPERTY(QString fileName READ fileName CONSTANT)
    Q_PROPERTY(qint64 fileSize READ fileSize CONSTANT)
 
public:
    enum Direction {
        IncomingDirection,  
        OutgoingDirection   
    };
    Q_ENUM(Direction)
 
    
    enum Error {
        NoError = 0,       
        AbortError,        
        FileAccessError,   
        FileCorruptError,  
        ProtocolError      
    };
    Q_ENUM(Error)
 
    
    enum Method {
        NoMethod = 0,      
        InBandMethod = 1,  
        SocksMethod = 2,   
        AnyMethod = 3      
    };
    Q_ENUM(Method)
    Q_DECLARE_FLAGS(Methods, Method)
 
    
    enum State {
        OfferState = 0,     
        StartState = 1,     
        TransferState = 2,  
        FinishedState = 3   
    };
    Q_ENUM(State)
 
    ~QXmppTransferJob() override;
 
    // documentation needs to be here, see https://stackoverflow.com/questions/49192523/
    QXmppTransferJob::Direction direction() const;
    QString jid() const;
    QXmppTransferJob::Method method() const;
    QXmppTransferJob::State state() const;
 
    QXmppTransferJob::Error error() const;
    QString sid() const;
    qint64 speed() const;
 
    // XEP-0096 : File transfer
    QXmppTransferFileInfo fileInfo() const;
    // documentation needs to be here, see https://stackoverflow.com/questions/49192523/
    QUrl localFileUrl() const;
    void setLocalFileUrl(const QUrl &localFileUrl);

    QDateTime fileDate() const;
    QByteArray fileHash() const;
    QString fileName() const;
    qint64 fileSize() const;
 
Q_SIGNALS:
    void error(QXmppTransferJob::Error error);

    void finished();

    void localFileUrlChanged(const QUrl &localFileUrl);

    void progress(qint64 done, qint64 total);

    void stateChanged(QXmppTransferJob::State state);
 
public Q_SLOTS:
    void abort();
    void accept(const QString &filePath);
    void accept(QIODevice *output);
 
private Q_SLOTS:
    void _q_terminated();
 
private:
    QXmppTransferJob(const QString &jid, QXmppTransferJob::Direction direction, QXmppClient *client, QObject *parent);
    void setState(QXmppTransferJob::State state);
    void terminate(QXmppTransferJob::Error error);
 
    const std::unique_ptr<QXmppTransferJobPrivate> d;
    friend class QXmppTransferManager;
    friend class QXmppTransferManagerPrivate;
    friend class QXmppTransferIncomingJob;
    friend class QXmppTransferOutgoingJob;
};
 
class QXMPP_EXPORT QXmppTransferManager : public QXmppClientExtension
{
    Q_OBJECT

    Q_PROPERTY(QString proxy READ proxy WRITE setProxy)
    Q_PROPERTY(bool proxyOnly READ proxyOnly WRITE setProxyOnly)
    Q_PROPERTY(QXmppTransferJob::Methods supportedMethods READ supportedMethods WRITE setSupportedMethods)
 
public:
    QXmppTransferManager();
    ~QXmppTransferManager() override;
 
    // documentation needs to be here, see https://stackoverflow.com/questions/49192523/
    QString proxy() const;
    void setProxy(const QString &proxyJid);
 
    // documentation needs to be here, see https://stackoverflow.com/questions/49192523/
    bool proxyOnly() const;
    void setProxyOnly(bool proxyOnly);
 
    // documentation needs to be here, see https://stackoverflow.com/questions/49192523/
    QXmppTransferJob::Methods supportedMethods() const;
    void setSupportedMethods(QXmppTransferJob::Methods methods);

    QStringList discoveryFeatures() const override;
    bool handleStanza(const QDomElement &element) override;
 
Q_SIGNALS:
    void fileReceived(QXmppTransferJob *job);

    void jobStarted(QXmppTransferJob *job);

    void jobFinished(QXmppTransferJob *job);
 
public Q_SLOTS:
    QXmppTransferJob *sendFile(const QString &jid, const QString &filePath, const QString &description = QString());
    QXmppTransferJob *sendFile(const QString &jid, QIODevice *device, const QXmppTransferFileInfo &fileInfo, const QString &sid = QString());
 
protected:
    void onRegistered(QXmppClient *client) override;
    void onUnregistered(QXmppClient *client) override;
 
private Q_SLOTS:
    void _q_iqReceived(const QXmppIq &);
    void _q_jobDestroyed(QObject *object);
    void _q_jobError(QXmppTransferJob::Error error);
    void _q_jobFinished();
    void _q_jobStateChanged(QXmppTransferJob::State state);
    void _q_socksServerConnected(QTcpSocket *socket, const QString &hostName, quint16 port);
 
private:
    const std::unique_ptr<QXmppTransferManagerPrivate> d;
 
    void byteStreamIqReceived(const QXmppByteStreamIq &);
    void byteStreamResponseReceived(const QXmppIq &);
    void byteStreamResultReceived(const QXmppByteStreamIq &);
    void byteStreamSetReceived(const QXmppByteStreamIq &);
    void ibbCloseIqReceived(const QXmppIbbCloseIq &);
    void ibbDataIqReceived(const QXmppIbbDataIq &);
    void ibbOpenIqReceived(const QXmppIbbOpenIq &);
    void ibbResponseReceived(const QXmppIq &);
    void streamInitiationIqReceived(const QXmppStreamInitiationIq &);
    void streamInitiationResultReceived(const QXmppStreamInitiationIq &);
    void streamInitiationSetReceived(const QXmppStreamInitiationIq &);
    void socksServerSendOffer(QXmppTransferJob *job);
 
    friend class QXmppTransferManagerPrivate;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(QXmppTransferJob::Methods)
 
#endif