coreengine.h

Go to the documentation of this file.

/*
    This file is part of KNewStuff2.
    Copyright (c) 2007 Josef Spillner <spillner@kde.org>
    Copyright (c) 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef KNEWSTUFF2_COREENGINE_H
#define KNEWSTUFF2_COREENGINE_H

#include <knewstuff2/core/provider.h>
#include <knewstuff2/core/entry.h>

#include <knewstuff2/knewstuff_export.h>

#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtCore/QMap>

class KJob;
class KArchiveDirectory;

namespace KNS
{

class Installation;

class KNEWSTUFF_EXPORT CoreEngine : public QObject
{
    Q_OBJECT
public:
    CoreEngine(QObject* parent);

    ~CoreEngine();

    enum CachePolicy {
        CacheNever,
        CacheReplaceable,
        CacheResident,
        CacheOnly
    };

    enum AutomationPolicy {
        AutomationOn,
        AutomationOff
    };

    void setAutomationPolicy(AutomationPolicy policy);
    void setCachePolicy(CachePolicy policy);

    bool init(const QString &configfile);

    void start();

    void loadEntries(Provider *provider);
    //void loadProvider(); // FIXME: for consistency?

    void downloadPreview(Entry *entry);

    void downloadPayload(Entry *entry);

    bool uploadEntry(Provider *provider, Entry *entry);

    bool install(const QString& payloadfile);

    bool uninstall(KNS::Entry *entry);

    QString componentName() const;

Q_SIGNALS:
    void signalProviderLoaded(KNS::Provider *provider);
    void signalProviderChanged(KNS::Provider *provider);
    void signalProvidersFailed();

    void signalEntryLoaded(KNS::Entry *entry, const KNS::Feed *feed, const KNS::Provider *provider);
    void signalEntryRemoved(KNS::Entry *entry, const KNS::Feed *feed);
    void signalEntryChanged(KNS::Entry *entry);
    void signalEntriesFailed();

    void signalPreviewLoaded(KUrl preview); // FIXME: return Entry
    void signalPreviewFailed();

    void signalPayloadLoaded(KUrl payload); // FIXME: return Entry
    void signalPayloadFailed(KNS::Entry *entry);

    void signalEntryUploaded(); // FIXME: rename to signalEntryUploadFinished?
    void signalEntryFailed(); // FIXME: rename to signalEntryUploadFailed?

    void signalProvidersFinished();
    void signalEntriesFinished();
    void signalEntriesFeedFinished(const KNS::Feed *feed);

    void signalInstallationFinished();
    void signalInstallationFailed();

    void signalProgress(const QString & message, int percentage);

    void signalDownloadDialogDone(KNS::Entry::List);
protected:
    void mergeEntries(Entry::List entries, Feed *feed, const Provider *provider);
private Q_SLOTS:
    void slotProvidersLoaded(KNS::Provider::List list);
    void slotProvidersFailed();

    void slotEntriesLoaded(KNS::Entry::List list);
    void slotEntriesFailed();

    void slotPayloadResult(KJob *job);
    void slotPreviewResult(KJob *job);

    void slotUploadPayloadResult(KJob *job);
    void slotUploadPreviewResult(KJob *job);
    void slotUploadMetaResult(KJob *job);

    void slotProgress(KJob *job, unsigned long percent);

    void slotInstallationVerification(int result);

private:
    void loadRegistry();
    void loadProvidersCache();
    KNS::Entry *loadEntryCache(const QString& filepath);
#if 0
    void loadEntriesCache();
#endif
    void loadFeedCache(Provider *provider);
    void cacheProvider(Provider *provider);
    void cacheEntry(Entry *entry);

    void cacheFeed(const Provider *provider, const QString & feedname, const Feed *feed, Entry::List entries);
    void registerEntry(Entry *entry);
    void unregisterEntry(Entry *entry);
    void mergeProviders(Provider::List providers);
    void shutdown();

    bool entryCached(Entry *entry);
    bool entryChanged(Entry *oldentry, Entry *entry);
    bool providerCached(Provider *provider);
    bool providerChanged(Provider *oldprovider, Provider *provider);

    static QStringList archiveEntries(const QString& path, const KArchiveDirectory * dir);

    QString id(Entry *e);
    QString pid(const Provider *p);

    QList<Provider*> m_provider_cache;

    // holds all the entries
    QList<Entry*> m_entry_cache;

    // holds the registered entries mapped by their id
    QMap<QString, Entry*> m_entry_registry;

    QMap<QString, Provider*> m_provider_index;
    QMap<QString, Entry*> m_entry_index;

    Entry *m_uploadedentry;
    Provider *m_uploadprovider;

    QString m_providersurl;
    QString m_componentname;

    QMap<Entry*, QString> m_previewfiles;
    QMap<Entry*, QString> m_payloadfiles;

    QMap<KJob*, Entry*> m_entry_jobs;

    Installation *m_installation;

    int m_activefeeds;

    bool m_initialized;
    CachePolicy m_cachepolicy;
    AutomationPolicy m_automationpolicy;
};

}

#endif