resourcebase.h

/*
    This file is part of akonadiresources.

    SPDX-FileCopyrightText: 2006 Till Adam <[email protected]>
    SPDX-FileCopyrightText: 2007 Volker Krause <[email protected]>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#ifndef AKONADI_RESOURCEBASE_H
#define AKONADI_RESOURCEBASE_H

#include "akonadiagentbase_export.h"
#include "agentbase.h"
#include "collection.h"
#include "item.h"
#include "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 AKONADIAGENTBASE_EXPORT ResourceBase : public AgentBase
{
    Q_OBJECT

public:
    template <typename T>
    static int init(int argc, char **argv)
    {

        // Disable session management
        qunsetenv("SESSION_MANAGER");

        QApplication app(argc, argv);
        debugAgent(argc, argv);
        const QString id = parseArguments(argc, argv);
        T r(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 != nullptr) {
            r.registerObserver(observer);
        }

        return init(r);
    }

    void setName(const QString &name);

    Q_REQUIRED_RESULT 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;

    virtual void retrieveTags();

    virtual void retrieveRelations();

    virtual void retrieveCollectionAttributes(const Akonadi::Collection &collection);

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

    int itemSyncBatchSize() const;

    void setItemSyncBatchSize(int batchSize);

    void setScheduleAttributeSyncBeforeItemSync(bool);

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

    virtual bool retrieveItems(const Akonadi::Item::List &items, const QSet<QByteArray> &parts);

    virtual void abortActivity();

    virtual QString dumpResourceToString() const
    {
        return QString();
    }

protected:
    ResourceBase(const QString &id);

    ~ResourceBase() override;

    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 tagsRetrieved(const Tag::List &tags, const QHash<QString, Item::List> &tagMembers);
    void relationsRetrieved(const Relation::List &relations);

    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;

    AKONADIAGENTBASE_DEPRECATED Item currentItem() const;

    Item::List currentItems() const;

    void synchronize();

    void synchronizeCollection(qint64 id);

    void synchronizeCollection(qint64 id, bool recursive);

    void synchronizeCollectionAttributes(qint64 id);

    void synchronizeCollectionAttributes(const Akonadi::Collection &col);

    void synchronizeCollectionTree();

    void synchronizeTags();

    void synchronizeRelations();

    void cancelTask();

    void cancelTask(const QString &error);

    void deferTask();

    void doSetOnline(bool online) override;

    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 argc, char **argv);
    static int init(ResourceBase &r);

    // dbus resource interface
    friend class ::Akonadi__ResourceAdaptor;

    void requestItemDelivery(const QVector<qint64> &uids, const QByteArrayList &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 *, quint64))
    Q_PRIVATE_SLOT(d_func(), void slotDelayedEmitProgress())
    Q_PRIVATE_SLOT(d_func(), void slotPrepareItemRetrieval(const Akonadi::Item &items))
    Q_PRIVATE_SLOT(d_func(), void slotPrepareItemRetrievalResult(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotPrepareItemsRetrieval(const QVector<Akonadi::Item> &items))
    Q_PRIVATE_SLOT(d_func(), void slotPrepareItemsRetrievalResult(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 slotTagSyncDone(KJob *))
    Q_PRIVATE_SLOT(d_func(), void slotRelationSyncDone(KJob *job))
    Q_PRIVATE_SLOT(d_func(), void slotSynchronizeTags())
    Q_PRIVATE_SLOT(d_func(), void slotSynchronizeRelations())
    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