userexchangemanager.h

#ifndef QTDATASYNC_USEREXCHANGEMANAGER_H
#define QTDATASYNC_USEREXCHANGEMANAGER_H

#include <QtCore/qobject.h>
#include <QtCore/qscopedpointer.h>
#include <QtCore/qshareddata.h>

#include <QtNetwork/qhostaddress.h>

#include "QtDataSync/qtdatasync_global.h"

namespace QtDataSync {

class AccountManager;

class UserInfoPrivate;
class Q_DATASYNC_EXPORT UserInfo
{
    Q_GADGET
    friend class UserInfoPrivate;

    Q_PROPERTY(QString name READ name CONSTANT)
    Q_PROPERTY(QHostAddress address READ address CONSTANT)
    Q_PROPERTY(quint16 port READ port CONSTANT)

public:
    UserInfo();
    UserInfo(const UserInfo &other);
    UserInfo(UserInfo &&other) noexcept;
    UserInfo(UserInfoPrivate *data);
    ~UserInfo();

    UserInfo &operator=(const UserInfo &other);
    UserInfo &operator=(UserInfo &&other) noexcept;

    QString name() const;
    QHostAddress address() const;
    quint16 port() const;

    bool operator==(const UserInfo &other) const;
    bool operator!=(const UserInfo &other) const;

private:
    QSharedDataPointer<UserInfoPrivate> d;
};

class UserExchangeManagerPrivate;
class Q_DATASYNC_EXPORT UserExchangeManager : public QObject
{
    Q_OBJECT

    Q_PROPERTY(QString setupName READ setupName NOTIFY setupNameChanged REVISION 2)
    Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)
    Q_PROPERTY(QList<QtDataSync::UserInfo> devices READ devices NOTIFY devicesChanged)

public:
    static const quint16 DataExchangePort;

    explicit UserExchangeManager(QObject *parent = nullptr);
    explicit UserExchangeManager(const QString &setupName, QObject *parent = nullptr);
    explicit UserExchangeManager(AccountManager *manager, QObject *parent = nullptr);
    ~UserExchangeManager() override;

    AccountManager *accountManager() const;

    QString setupName() const;
    quint16 port() const;
    bool isActive() const;
    QList<UserInfo> devices() const;

    Q_INVOKABLE void exportTo(const QtDataSync::UserInfo &userInfo, bool includeServer);
    Q_INVOKABLE void exportTrustedTo(const QtDataSync::UserInfo &userInfo, bool includeServer, const QString &password);
    void importFrom(const QtDataSync::UserInfo &userInfo,
                    const std::function<void(bool,QString)> &completedFn,
                    bool keepData = false);
    void importTrustedFrom(const QtDataSync::UserInfo &userInfo,
                           const QString &password,
                           const std::function<void(bool,QString)> &completedFn,
                           bool keepData = false);

public Q_SLOTS:
    inline bool startExchange(quint16 port = DataExchangePort) {
        return startExchange(QHostAddress::Any, port);
    }
    bool startExchange(const QHostAddress &listenAddress, quint16 port = DataExchangePort);
    void stopExchange();

Q_SIGNALS:
    void userDataReceived(const QtDataSync::UserInfo &userInfo, bool trusted, QPrivateSignal);
    void exchangeError(const QString &errorString, QPrivateSignal);

    QT_DATASYNC_REVISION_2 void setupNameChanged(const QString &setupName, QPrivateSignal);
    void activeChanged(bool active, QPrivateSignal);
    void devicesChanged(QList<QtDataSync::UserInfo> devices, QPrivateSignal);

protected:
    UserExchangeManager(QObject *parent, void*);
    void initManager(AccountManager *manager);

private Q_SLOTS:
    void timeout();
    void readDatagram();

private:
    QScopedPointer<UserExchangeManagerPrivate> d;
};

Q_DATASYNC_EXPORT uint qHash(const QtDataSync::UserInfo &info, uint seed = 0);
Q_DATASYNC_EXPORT QDebug operator<<(QDebug stream, const QtDataSync::UserInfo &userInfo);

}

Q_DECLARE_METATYPE(QtDataSync::UserInfo)
Q_DECLARE_TYPEINFO(QtDataSync::UserInfo, Q_MOVABLE_TYPE);

#endif // QTDATASYNC_USEREXCHANGEMANAGER_H