synchronizer.h

/*
 * This file is part of buteo-syncfw package
 *
 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 * Copyright (C) 2014-2019 Jolla Ltd.
 * Copyright (C) 2020 Open Mobile Platform LLC.
 *
 * Contact: Sateesh Kavuri <sateesh.kavuri@nokia.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * version 2.1 as published by the Free Software Foundation.
 *
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */
#ifndef SYNCHRONIZER_H
#define SYNCHRONIZER_H
 
#include "SyncDBusInterface.h"
#include "SyncQueue.h"
#include "StorageBooker.h"
#include "SyncScheduler.h"
#include "SyncBackup.h"
#include "SyncOnChange.h"
#include "SyncOnChangeScheduler.h"
 
#include "SyncCommonDefs.h"
#include "ProfileManager.h"
#include "PluginManager.h"
#include "PluginCbInterface.h"
#include "ClientPlugin.h"
 
#include <QVector>
#include <QMutex>
#include <QCoreApplication>
#include <QMap>
#include <QString>
#include <QDBusInterface>
#include <QScopedPointer>
#include <QTimer>
 
struct _GSettings;
 
namespace Buteo {
 
class PluginManager;
class ServerPluginRunner;
class NetworkManager;
class TransportTracker;
class ServerActivator;
class AccountsHelper;
class BatteryInfo;
 
class Synchronizer : public SyncDBusInterface, // Derived from QObject
                     public PluginCbInterface
{
    Q_OBJECT
public:
 
    Synchronizer(QCoreApplication *aApplication);
 
    virtual ~Synchronizer();
 
    bool initialize();
 
    void close();
 
 
// From PluginCbInterface
// ---------------------------------------------------------------------------
    virtual bool requestStorage(const QString &aStorageName,
                                const SyncPluginBase *aCaller);
 
    virtual void releaseStorage(const QString &aStorageName,
                                const SyncPluginBase *aCaller);
 
    virtual StoragePlugin* createStorage(const QString &aPluginName);
 
    virtual void destroyStorage(StoragePlugin *aStorage);
 
    virtual bool isConnectivityAvailable( Sync::ConnectivityType aType );
 
    virtual Profile* getSyncProfileByRemoteAddress(const QString& aAddress);
 
    virtual QString getValue(const QString& aAddress, const QString& aKey);
 
 
// From SyncDBusInterface
// --------------------------------------------------------------------------
 
public slots:
 
    virtual bool startSync(QString aProfileName);
 
    virtual void abortSync(QString aProfileName);
 
    virtual bool removeProfile(QString aProfileAsXml);
 
    virtual bool updateProfile(QString aProfileAsXml);
 
    virtual bool requestStorages(QStringList aStorageNames);
 
    virtual void releaseStorages(QStringList aStorageNames);
 
    virtual QStringList runningSyncs();
 
    virtual bool setSyncSchedule(QString aProfileId , QString aScheduleAsXml);
 
    virtual bool saveSyncResults(QString aProfileId,QString aSyncResults);
 
    virtual QString createSyncProfileForAccount(uint aAccountId);
 
    virtual QString getLastSyncResult(const QString &aProfileId);
 
    virtual QStringList allVisibleSyncProfiles();
 
    virtual QString syncProfile(const QString &aProfileId);
    virtual QStringList syncProfilesByKey(const QString &aKey, const QString &aValue);
    virtual QStringList syncProfilesByType(const QString &aType);
// --------------------------------------------------------------------------
 
    bool startScheduledSync(QString aProfileName);
 
    void backupStarts();
 
    void backupFinished();
 
    void restoreStarts();
 
    void restoreFinished();
 
    virtual bool getBackUpRestoreState();
 
    void start(unsigned int aAccountId);
 
    void stop(unsigned int aAccountId);
 
    QList<unsigned int> syncingAccounts();
 
    int status(unsigned int aAccountId, int &aFailedReason, qlonglong &aPrevSyncTime, qlonglong &aNextSyncTime);
 
    void isSyncedExternally(unsigned int aAccountId, const QString aClientProfileName);
 
signals:
 
    void storageReleased();
 
    void syncDone(const QString &aProfileName);
 
private slots:
 
    void onStorageReleased();
 
    void onTransferProgress( const QString &aProfileName,
        Sync::TransferDatabase aDatabase, Sync::TransferType aType,
        const QString &aMimeType, int aCommittedItems );
 
    void onSessionFinished( const QString &aProfileName,
        Sync::SyncStatus aStatus, const QString &aMessage, int aErrorCode );
 
    void onStorageAccquired(const QString &aProfileName, const QString &aMimeType);
 
    void onSyncProgressDetail(const QString &aProfileName,int aProgressDetail);
 
    void onServerDone();
 
    void onNewSession(const QString &aDestination);
 
    void slotProfileChanged(QString aProfileName, int aChangeType , QString aProfileAsXml);
 
    void startServer(const QString &aProfileName);
 
    void stopServer(const QString &aProfileName);
 
    void onNetworkStateChanged(bool aState, Sync::InternetConnectionType type);
 
    void enableSOCSlot(const QString& aProfileName);
 
    void reschedule(const QString &aProfileName);
 
    void slotSyncStatus(QString aProfileName, int aStatus,
                        QString aMessage, int aMoreDetails);
 
    void removeScheduledSync(const QString &aProfileName);
 
    void externalSyncStatus(const QString &aProfileName, bool aQuery);
 
    void profileChangeTriggerTimeout();
 
private:
 
    bool startSync(const QString &aProfileName, bool aScheduled);
 
    bool startSyncNow(SyncSession *aSession);
 
    bool startNextSync();
 
    void cleanupSession(SyncSession *aSession, Sync::SyncStatus aStatus);
 
    void startServers( bool resume = false );
 
    void stopServers( bool suspend = false );
 
     void backupRestoreStarts ();
 
     void backupRestoreFinished();
 
    void initializeScheduler();
 
    bool isBackupRestoreInProgress ();
 
    bool cleanupProfile(const QString &profileId);
 
    bool clientProfileActive(const QString &clientProfileName);
 
    void removeExternalSyncStatus(const SyncProfile *aProfile);
 
    bool acceptScheduledSync(bool aConnected, Sync::InternetConnectionType aType, SyncProfile *profile) const;
 
    void externalSyncStatus(const SyncProfile *aProfile, bool aQuery=false);
 
    QMap<QString, SyncSession*> iActiveSessions;
 
    QMap<QString, bool> iExternalSyncProfileStatus;
 
    QList<QString> iProfilesToRemove;
 
    QMap<QString, ServerPluginRunner*> iServers;
 
    QList<QString> iWaitingOnlineSyncs;
 
    NetworkManager *iNetworkManager;
 
    QMap<QString, int> iCountersStorage;
 
    PluginManager iPluginManager;
 
    ProfileManager iProfileManager;
 
    SyncQueue iSyncQueue;
 
    StorageBooker iStorageBooker;
 
    SyncScheduler *iSyncScheduler;
 
    SyncBackup *iSyncBackup;
 
    TransportTracker *iTransportTracker;
 
    ServerActivator *iServerActivator;
 
    AccountsHelper *iAccounts;
 
    bool iClosing;
 
    SyncOnChange iSyncOnChange;
 
    SyncOnChangeScheduler iSyncOnChangeScheduler;
 
    void saveProfileCounter(const SyncProfile* aProfile);
 
    void restoreProfileCounter(SyncProfile* aProfile);
 
    bool iSOCEnabled;
 
    QString iUUID;
 
    QString iRemoteName;
 
    /*
     * Temporary, until we can clean up Buteo and properly implement the SyncOnChange
     * queue to handle all of the required changes (account + profile + connectivity)
     * in a sane manner (also taking into account BackupRestore status).
     * However, that change will be far more invasive, so for now this is much simpler.
     */
    QList<QPair<QString, ProfileManager::ProfileChangeType> > iProfileChangeTriggerQueue;
    QTimer iProfileChangeTriggerTimer;
 
#ifdef SYNCFW_UNIT_TESTS
    friend class SynchronizerTest;
#endif
 
    QDBusInterface *iSyncUIInterface;
    _GSettings *iSettings;
    BatteryInfo *iBatteryInfo;
};
 
}
 
#endif // SYNCHRONIZER_H