~apachelogger/ubuntuone-client/gsoc

/*

  Copyright © 2010 Harald Sitter <apachelogger@ubuntu.com>

  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) version 3 or any later version

  accepted by the membership of KDE e.V. (or its successor approved

  by the membership of KDE e.V.), which shall act as a proxy

  defined in Section 14 of version 3 of the license.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "SyncDaemon.h"

#include <QtCore/QDebug>

#include <KFilePlacesModel>

#include "ComUbuntuSsoInterface.h"

#include "SyncDaemonDBus.h"

namespace UbuntuOne

{

    class SyncDaemonPrivate

    {

    public:

        Q_DECLARE_PUBLIC(SyncDaemon)

        SyncDaemonPrivate(SyncDaemon *q) :

            q_ptr(q),

            m_rootDir(QDir()),

            m_queueCount(0)

        {

        }

        ~SyncDaemonPrivate()

        {

            delete auth;

            delete daemon;

            delete status;

        }

        SyncDaemon *const q_ptr;

        QDir m_rootDir;

        int m_queueCount;

        QStringList m_uploading;

        QStringList m_downloading;

        ComUbuntuSsoInterface *auth;

        ComUbuntuoneSyncDaemonSyncDaemonInterface *daemon;

        ComUbuntuoneSyncDaemonStatusInterface *status;

        void updateRootDir();

        void setRootDir(const QString &root);

        void updateQueues();

        //        void updateTransferStatus();

        //        void updatingCompleted();

    };

    void SyncDaemonPrivate::updateRootDir()

    {

        setRootDir(daemon->get_rootdir());

    }

    void SyncDaemonPrivate::setRootDir(const QString &root)

    {

        Q_Q(SyncDaemon);

        // Ifing here is really not worth anything. Just try setting whatever

        // we got as root, if the path was crap, it will be acted upon below.

        m_rootDir.setPath(root);

        if (!m_rootDir.exists()) {

            return;

        }

        KFilePlacesModel places;

        KUrl url = KUrl(m_rootDir.path());

        if (places.url(places.closestItem(url)) != url) {

            places.addPlace("Ubuntu One", url, "ubuntuone-kde");

        }

        q->statusChanged(status->current_status());

    }

    void SyncDaemonPrivate::updateQueues()

    {

        status->current_status();

    }

////////////////////////////////// Public //////////////////////////////////

    SyncDaemon::SyncDaemon(QObject *parent) :

        QObject(parent),

        d_ptr(new SyncDaemonPrivate(this))

    {

        qRegisterMetaType<QStringHash>("QStringHash");

        qDBusRegisterMetaType<QStringHash>();

        qRegisterMetaType<QStringHashHash>("QStringHashHash");

        qDBusRegisterMetaType<QStringHashHash>();

        Status::registerMetaType();

        Share::registerMetaType();

        Q_D(SyncDaemon);

        d->auth =

            new ComUbuntuSsoInterface("com.ubuntu.sso",

                    "/", QDBusConnection::sessionBus(),

                    this);

        d->daemon =

            new ComUbuntuoneSyncDaemonSyncDaemonInterface("com.ubuntuone.SyncDaemon",

                    "/", QDBusConnection::sessionBus(),

                    this);

        d->status =

            new ComUbuntuoneSyncDaemonStatusInterface("com.ubuntuone.SyncDaemon",

                    "/status", QDBusConnection::sessionBus(),

                    this);

        connect(d->auth, SIGNAL(NewCredentials(QString, QString)),

                this, SLOT(receivedCredentials(QString, QString)));

        connect(d->status, SIGNAL(StatusChanged(UbuntuOne::Status)),

                this, SLOT(statusChanged(UbuntuOne::Status)));

        connect(d->status, SIGNAL(ContentQueueChanged(QStringHashHash)),

                this, SLOT(contentQueueChanged(QStringHashHash)));

        connect(d->status, SIGNAL(UploadStarted(QString)),

                this, SLOT(uploadStarted(QString)));

        connect(d->status, SIGNAL(UploadFinished(QString,QStringHash)),

                this, SLOT(uploadFinished(QString,QStringHash)));

        connect(d->status, SIGNAL(DownloadStarted(QString)),

                this, SLOT(downloadStarted(QString)));

        connect(d->status, SIGNAL(DownloadFinished(QString,QStringHash)),

                this, SLOT(downloadFinished(QString,QStringHash)));

        // TODO: revisit this. I am not sure if this should be here, more likely

        // it should be added to the connection process.

        d->auth->maybe_login("https://one.ubuntu.com", "ubuntuone", true);

    }

    SyncDaemon::~SyncDaemon()

    {

        delete d_ptr;

    }

    void SyncDaemon::updateStatus()

    {

        Q_D(SyncDaemon);

        d->updateRootDir(); // calls statusChanged if successful

        d->updateQueues();

    }

    QString SyncDaemon::rootDir() const

    {

        Q_D(const SyncDaemon);

        return d->daemon->get_rootdir();

    }

    void SyncDaemon::connectDaemon() const

    {

        Q_D(const SyncDaemon);

        Status dstatus = d->status->current_status();

        if (!dstatus.isConnected()) {

            qDebug() << "connecting to cloud";

            d->daemon->disconnect();

            d->daemon->connect();

        }

    }

    void SyncDaemon::disconnectDaemon() const

    {

        Q_D(const SyncDaemon);

        qDebug() << "disconnecting from cloud";

        d->daemon->disconnect();

    }

    void SyncDaemon::restartDaemon() const

    {

        Q_D(const SyncDaemon);

        d->daemon->quit();

        connectDaemon();

    }

    void SyncDaemon::statusChanged(const UbuntuOne::Status &status)

    {

        Q_D(SyncDaemon);

        if (d->m_rootDir.path().isEmpty()) {

            return d->updateRootDir();

        }

        switch (status.state()) {

        case Status::Error : {

            switch (status.errorState()) {

            case Status::AuthFailed : emit authFailed(); break;

            case Status::CapabilitiesMismatch : emit capabilitiesMismatch(); break;

            case Status::UnkownError : emit unkownErrorOccurred(); break;

            }

        }

        case Status::Disconnected : emit disconnected(); break;

        case Status::Connecting : emit connecting(); break;

        default : emit idle(); break;

        }

    }

    void SyncDaemon::receivedCredentials(const QString &realm,

                                         const QString &consumerKey)

    {

        Q_UNUSED(realm);

        Q_UNUSED(consumerKey);

        Q_D(SyncDaemon);

        connectDaemon();

        d->updateRootDir();

    }

    void SyncDaemon::contentQueueChanged(const QStringHashHash &queue)

    {

        qDebug() << "contentQueueChanged:" << queue;

        Q_D(SyncDaemon);

        bool ok;

        int count = queue.value("Upload").value("count").toInt(&ok);

        qDebug() << ok;

        qDebug() << count;

        if (ok) {

            d->m_queueCount = count;

        } else {

            d->m_queueCount = 0;

        }

        count = queue.value("Download").value("count").toInt(&ok);

        if (ok) {

            d->m_queueCount = d->m_queueCount + count;

        }

        emit queueUpdated(d->m_queueCount);

    }

    void SyncDaemon::uploadStarted(const QString &path)

    {

        qDebug() << "uploadStarted:" << path;

        Q_D(SyncDaemon);

        d->m_uploading.append(path);

        qDebug() << d->m_uploading;

        emit uploading(d->m_uploading, d->m_queueCount);

    }

    void SyncDaemon::uploadFinished(const QString &path, const QStringHash &info)

    {

        qDebug() << "uploadFinished:" << path;

        qDebug() << "uploadFinished:" << info;

        Q_D(SyncDaemon);

        d->m_uploading.removeAt(d->m_uploading.indexOf(path));

    }

    void SyncDaemon::downloadStarted(const QString &path)

    {

        qDebug() << "downloadStarted:" << path;

        Q_D(SyncDaemon);

        d->m_downloading.append(path);

        qDebug() << d->m_downloading;

        emit downloading(d->m_downloading, d->m_queueCount);

    }

    void SyncDaemon::downloadFinished(const QString &path, const QStringHash &info)

    {

        qDebug() << "downloadFinished:" << path;

        qDebug() << "downloadFinished:" << info;

        Q_D(SyncDaemon);

        d->m_downloading.removeAt(d->m_downloading.indexOf(path));

    }

    void SyncDaemon::debugDBusMessage(const QDBusMessage &msg)

    {

        qDebug() << msg;

    }

} // namespace UbuntuOne