resourcebase.h

/*
    This file is part of akonadiresources.

    Copyright (c) 2006 Till Adam <adam@kde.org>
    Copyright (c) 2007 Volker Krause <vkrause@kde.org>

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

    This library 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 Library General Public
    License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef AKONADI_RESOURCEBASE_H
#define AKONADI_RESOURCEBASE_H

#include "akonadi_export.h"

#include <akonadi/agentbase.h>
#include <akonadi/collection.h>
#include <akonadi/item.h>
#include <akonadi/itemsync.h>

class KJob;
class Akonadi__ResourceAdaptor;
class ResourceState;

namespace Akonadi {

class ResourceBasePrivate;

// FIXME_API: API dox need to be updated for Observer approach (kevin)
class AKONADI_EXPORT ResourceBase : public AgentBase
{
    Q_OBJECT

public:
    template <typename T>
    static int init(int argc, char **argv)
    {
        const QString id = parseArguments(argc, argv);
        KApplication app;
        T *r = new T(id);

        // check if T also inherits AgentBase::Observer and
        // if it does, automatically register it on itself
        Observer *observer = dynamic_cast<Observer *>(r);
        if (observer != 0) {
            r->registerObserver(observer);
        }

        return init(r);
    }

    void setName(const QString &name);

    QString name() const;

    void setAutomaticProgressReporting(bool enabled);

Q_SIGNALS:
    void nameChanged(const QString &name);

    void synchronized();

    void attributesSynchronized(qlonglong collectionId);

    void collectionTreeSynchronized();

    void retrieveNextItemSyncBatch(int remainingBatchSize);

protected Q_SLOTS:
    virtual void retrieveCollections() = 0;

    // KDE5: Make it pure virtual, for now can be called only by invokeMethod()
    //       in order to simulate polymorphism
    void retrieveCollectionAttributes(const Akonadi::Collection &collection);

    virtual void retrieveItems(const Akonadi::Collection &collection) = 0;

    int itemSyncBatchSize() const;

    void setItemSyncBatchSize(int batchSize);

    virtual bool retrieveItem(const Akonadi::Item &item, const QSet<QByteArray> &parts) = 0;

    // KDE5: Make it pure virtual, for now can be called only by invokeMethod()
    //       in order to simulate polymorphism
    void abortActivity();

    // KDE5: Make it pure virtual, for now can be called only by invokeMethod()
    //       in order to simulate polymorphism
    QString dumpResourceToString() const
    {
        return QString();
    }

protected:
    ResourceBase(const QString &id);

    ~ResourceBase();

    void itemRetrieved(const Item &item);

    void collectionAttributesRetrieved(const Collection &collection);

    void changeCommitted(const Item &item);

    void changesCommitted(const Item::List &items);

    void changeCommitted(const Tag &tag);

    void changeCommitted(const Collection &collection);

    void collectionsRetrieved(const Collection::List &collections);

    void collectionsRetrievedIncremental(const Collection::List &changedCollections,
                                         const Collection::List &removedCollections);

    void setCollectionStreamingEnabled(bool enable);

    void collectionsRetrievalDone();

    void setKeepLocalCollectionChanges(const QSet<QByteArray> &parts);

    void itemsRetrieved(const Item::List &items);

    void setTotalItems(int amount);

    void setDisableAutomaticItemDeliveryDone(bool disable);

    void setItemStreamingEnabled(bool enable);

    void setItemTransactionMode(ItemSync::TransactionMode mode);

    void setItemMergingMode(ItemSync::MergeMode mode);

    void setItemSynchronizationFetchScope(const ItemFetchScope &fetchScope);

    void itemsRetrievedIncremental(const Item::List &changedItems,
                                   const Item::List &removedItems);

    void itemsRetrievalDone();

    void clearCache();

    void invalidateCache(const Collection &collection);

    Collection currentCollection() const;

    Item currentItem() const;

    void synchronize();

    void synchronizeCollection(qint64 id);

    void synchronizeCollection(qint64 id, bool recursive);

    void synchronizeCollectionAttributes(qint64 id);

    void synchronizeCollectionTree();

    void cancelTask();

    void cancelTask(const QString &error);

    void deferTask();

    void doSetOnline(bool online);

    void setHierarchicalRemoteIdentifiersEnabled(bool enable);

    friend class ResourceScheduler;
    friend class ::ResourceState;

    enum SchedulePriority {
        Prepend,            
        AfterChangeReplay,  
        Append              
    };

    void scheduleCustomTask(QObject *receiver, const char *method, const QVariant &argument, SchedulePriority priority = Append);

    void taskDone();

    QString dumpNotificationListToString() const;

    void dumpMemoryInfo() const;

    QString dumpMemoryInfoToString() const;

    QString dumpSchedulerToString() const;

private:
    static QString parseArguments(int, char **);
    static int init(ResourceBase *r);

    // dbus resource interface
    friend class ::Akonadi__ResourceAdaptor;

    bool requestItemDelivery(qint64 uid, const QString &remoteId, const QString &mimeType, const QStringList &parts);

    QString requestItemDeliveryV2(qint64 uid, const QString &remoteId, const QString &mimeType, const QStringList &parts);

private:
    Q_DECLARE_PRIVATE(ResourceBase)

    Q_PRIVATE_SLOT(d_func(), void slotAbortRequested())
    Q_PRIVATE_SLOT(d_func(), void slotDeliveryDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotCollectionSyncDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotDeleteResourceCollection())
    Q_PRIVATE_SLOT(d_func(), void slotDeleteResourceCollectionDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotCollectionDeletionDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotInvalidateCache(const Akonadi::Collection &))
    Q_PRIVATE_SLOT(d_func(), void slotLocalListDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotSynchronizeCollection(const Akonadi::Collection &))
    Q_PRIVATE_SLOT(d_func(), void slotCollectionListDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotSynchronizeCollectionAttributes(const Akonadi::Collection &))
    Q_PRIVATE_SLOT(d_func(), void slotCollectionListForAttributesDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotCollectionAttributesSyncDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotItemSyncDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotPercent(KJob *, unsigned long))
    Q_PRIVATE_SLOT(d_func(), void slotDelayedEmitProgress())
    Q_PRIVATE_SLOT(d_func(), void slotPrepareItemRetrieval(const Akonadi::Item &item))
    Q_PRIVATE_SLOT(d_func(), void slotPrepareItemRetrievalResult(KJob *))
    Q_PRIVATE_SLOT(d_func(), void changeCommittedResult(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotSessionReconnected())
    Q_PRIVATE_SLOT(d_func(), void slotRecursiveMoveReplay(RecursiveMover *))
    Q_PRIVATE_SLOT(d_func(), void slotRecursiveMoveReplayResult(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotItemRetrievalCollectionFetchDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotAttributeRetrievalCollectionFetchDone(KJob *))
};

}

#ifndef AKONADI_RESOURCE_MAIN

#define AKONADI_RESOURCE_MAIN( resourceClass )                       \
  int main( int argc, char **argv )                                  \
  {                                                                  \
    return Akonadi::ResourceBase::init<resourceClass>( argc, argv ); \
  }
#endif

#endif