/*

* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Symbian OS server that dispatches SyncML client requests to various engine components. 

*

*/

#ifndef __NSMLSOSSERVER_H__

#define __NSMLSOSSERVER_H__

#ifndef SYNCML_V3

#define SYNCML_V3

#endif

// --------------------------------------------------------------------------

// Includes

// --------------------------------------------------------------------------

#include <e32base.h>

#include <e32property.h>

#include <s32mem.h> 

#include <badesca.h>

#include <SyncMLClient.h>

#include <SyncMLDef.h>

#include <SyncMLObservers.h>

#include <nsmlconstants.h>

#include "NSmlDMAgent.h"

#include "NSmlDSAgent.h"

#include "nsmldssettings.h"

#include "nsmldmsettings.h"

#include "nsmlsosserverdefs.h"

#include "NSmlAlertQueue.h"

#include "nsmlsosthread.h"

#include <sbeclient.h>

#include <abclient.h>

 #include <SettingEnforcementInfo.h>

class MNSmlSignalHandler;

class CNSmlThreadObserver;

// --------------------------------------------------------------------------

// Panic reasons

// --------------------------------------------------------------------------

enum TNSmlSOSServerPanic

    {

    ECleanupCreateError,

    EMainSchedulerError

    };

// --------------------------------------------------------------------------

// Class forwards

// --------------------------------------------------------------------------

class CSyncMLFilter;

class CNSmlSOSSession;

class CNSmlThreadParams;

class CNSmlThreadStart;

class MNSmlSignalHandler;

class CNSmlDSHostClient;

class CNSmlDSSettings;

/**

* Container class for a job progress events that have not

* been notified.

*

*  @since 

*/

struct TNSmlProgressEvent

    {

    TNSmlProgressEventType iEventType;

    MSyncMLProgressObserver::TStatus iProgressStatus;

    MSyncMLProgressObserver::TErrorLevel iErrorLevel;

    MSyncMLProgressObserver::TSyncMLDataSyncModifications iClientMods;

    MSyncMLProgressObserver::TSyncMLDataSyncModifications iServerMods;

    TInt iInfo1;

    TInt iInfo2;    

    TInt iInfo3;

    TInt iInfo4;

    };

/**

* Container class for a job events that have not

* been notified (ESmlJobStart, ESmlJobStop).  

*

*  @since 

*/

struct TNSmlJobEvent

    {

    MSyncMLEventObserver::TEvent iEvent;    

    TInt iEndStatus;

    TInt iJobId; 

    TUint dummy;   // not used : to prevent (UDEB) memmove panic                       

    };

/**

* Container class for a job created by client.

*  Job queue is comprised of CNSmlJob instances.

*

*  @since 

*/

class CNSmlJob : public CBase

	{

public:

	CNSmlJob();

	~CNSmlJob();

	TInt JobId() const;

	TInt ProfileId() const;

    TInt CreatorId() const;

    TInt TransportId() const;

	TSmlUsageType UsageType() const;

    TNSmlJobType JobType() const;

    TSmlSyncType SyncType() const;

    void TaskIds( RArray<TInt>& aTasks ) const;

    const CNSmlSOSSession* OwnerSession() const;

    CNSmlSOSSession* OwnerSessionNonConst() const;

	TBool JobRunning( ) const;

	void SetJobId( const TInt aJobId );

	void SetProfId( const TInt aProfId );

    void SetCreatorId( const TInt aCreatorId );

    void SetTransportId( const TInt aTransportId );

    void SetUsageType( const TSmlUsageType aUsageType );

    void SetJobType( const TNSmlJobType aJobType );

    void SetSyncType( const TSmlSyncType aSyncType );

    void AddTaskIdL( const TInt aTaskId );

    void SetOwnerSession( CNSmlSOSSession* aSession );

 	void SetJobRunning( const TBool aRunning );

 	void SetJobIapId(const TInt aIapId); 	

 	TInt GetJobIapId() const;

public:

	CNSmlJob* iNext;

    HBufC8* iPackage;

    TInt iSessionId;

    CArrayFix<TNSmlContentTypeInfo>* iCtInfo;

    TBool iPending;

	TBool iRunning;

	TBool iSilentJob;

	TInt iUimode;

private:

    TInt iJobId;

    TInt iProfId;

    TInt iCreatorId;

    TInt iTransportId;

    RArray<TInt> iTaskIds;

    TSmlUsageType iUsageType;

    TNSmlJobType iJobType;

    TSmlSyncType iSyncType;

    CNSmlSOSSession* iSession;    

    TInt iIapId;

	};

/**

* Object for a job sub session.

*

*  @since 

*/

class CNSmlJobObject : public CObject

	{

public:

	CNSmlJobObject();

	~CNSmlJobObject();

    TInt JobId() const;

    void SetJobId( const TInt aJobId );

private:

    TInt iJobId;        

	};

/**

* Object for a profile sub session.

*  This class is used for reading and updating profile data.

*

*  @since 

*/

class CNSmlProfile : public CObject

	{

public:

    CNSmlProfile( TSmlUsageType aUsageType, CNSmlSOSSession& aSession );

	~CNSmlProfile();

    TInt ProfileId() const;

    void SetLocked();

    TBool IsLocked();

    TInt FetchDataL( const TInt aId, TBool aAllowHidden );

    void ConnectionListL( RArray<TInt>& aArray );

    void TaskListL( RArray<TInt>& aArray );

    TInt DataSize();

    const TPtr8& ReadData();

    TInt UpdateDataL( TInt& aId , const TDesC8& aData, TBool& aIsHidden );

    TBool DeleteTaskL( const TInt aId );

    void SetCreatorId( const TInt aCreatorId );  

    TSmlUsageType GetUsageType();

private:

    TInt iProfId;

    const TSmlUsageType iUsageType;

    CNSmlSOSSession& iSession;

    TBool iLocked;

    TInt iCreatorId;

    CBufBase* iBuffer;

    TPtr8 iDataPtr;

	};

/**

* Object for a task sub session.

*  This class is used for reading and updating task data.

*

*  @since 

*/

class CNSmlTask : public CObject

	{

public:

	CNSmlTask( const TInt aProfId, TBool aNewTask, CNSmlSOSSession& aSession );

	~CNSmlTask();

    TInt FetchDataL( const TInt aTaskId );

    TInt GetSupportedFiltersL();

    TInt DataSize();

    const TPtr8& ReadData();

    TInt FilterSize();

    const TPtr8& ReadFilter();

    TInt UpdateDataL( TInt& aId, const TDesC8& aData );

    void SetCreatorId( const TInt aCreatorId );

    void SetDataProviderId(  const TInt aTaskUID );

    TInt PrepareFilterBufferL( const TInt aTaskId );

private:

	void PackFilterArrayL( RPointerArray<CSyncMLFilter>& aFilterArray, TInt aMatchType , TInt aChangeInfo = 0 );

private:

    const TInt iProfId;

    TBool iCreatingNew;

    CNSmlSOSSession& iSession;

    TInt iCreatorId;

    TInt iTaskUID;

    CBufBase* iBuffer;    

    TPtr8 	iDataPtr;   

    CBufBase* iFilterBuffer;    

    TPtr8 	iFilterBufPtr;

	};

/**

* Object for a connection sub session.

*  This class is used for reading and updating connection data.

*

*  @since 

*/

class CNSmlConnection : public CObject

	{

public:

	CNSmlConnection( const TInt aProfId, const TInt aTransId, CNSmlSOSSession& aSession );

	~CNSmlConnection();

    TInt FetchDataL();

    TInt DataSize();

    const TPtr8& ReadData();

    TInt UpdateDataL( const TDesC8& aData );

private:

    const TInt iProfId;

    const TInt iTransId;

    CNSmlSOSSession& iSession;

    CBufBase* iBuffer;

    TPtr8 iDataPtr;

	};

/**

* Object for a history log sub session.

*  This class is used for reading and resetting history log data.

*

*  @since 

*/

class CNSmlHistoryLog : public CObject

	{

public:

	CNSmlHistoryLog( const TInt aProfId, CNSmlSOSSession& aSession );

	~CNSmlHistoryLog();

    TInt FetchDataL();

    TInt DataSize();

    const TPtr8& ReadData();

    void ResetL();

private:

    const TInt iProfId;

    CNSmlSOSSession& iSession;

    CBufBase* iBuffer;

    HBufC8* iData;

    TPtr8 iDataPtr;

	};

/**

* Object for a data provider sub session.

*  This class is used for reading data provider data.

*

*  @since 

*/

class CNSmlDataProvider : public CObject

	{

public:

	CNSmlDataProvider( const TInt aId, CNSmlSOSSession& aSession );

	~CNSmlDataProvider();

    void FetchDataL();

    TInt DataSize();

    const TPtr8& ReadData();

private:

    const TInt iId;

    CBufBase* iBuffer;

    TPtr8 iDataPtr;

    CNSmlSOSSession& iSession;

	};

/**

* An active class for handling jobs, queuing and outstanding event and progress requests.

*  This class also keeps record of connected clients and closes server when it is not used.

*

*  @since 

*/

class CNSmlSOSHandler : public CActive, public MSyncMLProgressObserver, MNSmlAlertObserver 

	{

public:

    static CNSmlSOSHandler* NewL();

    ~CNSmlSOSHandler();

    void LockProfile( const TInt aProfId );

    void RemoveLock( const TInt aProfId );

    TBool IsLocked( const TInt aProfId );

    TInt AddJobL( CNSmlJob* aJob, TInt& aJobId );

    CNSmlJob* FindJob( TInt aJobId );

    TInt StopJob( const TInt aJobId, const TInt aCreatorId );

    void CurrentJob( TInt& aId, TSmlUsageType& aType );

    void QueuedJobsL( RArray<TInt>& aArray, const TSmlUsageType aType );

    void AddProgressMsgL( const RMessage2& aMessage );

    void AddContactSuiteProgressMsgL( const RMessage2& aMessage );

    TBool CompleteBufProgressMsg( const TDesC8& aBuf, const CNSmlSOSSession* aSession );

	TBool CompleteBufContactSuiteProgressMsg( const TDesC8& aBuf, const CNSmlSOSSession* aSession );

    void CancelProgressMsg( const CNSmlSOSSession* aSession );

    void CancelContactSuiteProgressMsg( const CNSmlSOSSession* aSession );

    void AddEventMsgL( const RMessage2& aMessagePtr );

    void CancelEventMsg( TInt aHandle );

    void CompleteEventMsgL( MSyncMLEventObserver::TEvent aEvent, TInt aId = 0, TInt aError = 0, TInt aAdditional = 0 );

    void ServerAlertL( TDesC8& aData, TSmlUsageType aType, TSmlProtocolVersion aVersion, TSmlTransportId aBearerType );

    // FOTA

    void GenericAlertL( HBufC8* aMgmtUri, HBufC8* aMetaType, HBufC8* aMetaFormat, TInt aFinalResult, HBufC8* aCorrelator );

	// FOTA end

    void GenericAlertL( HBufC8* aCorrelator, RArray<CNSmlDMAlertItem>* aItem  );

    void IncreaseSessionCount();

    void DecreaseSessionCount();

    void ServerSuspendedL( const TBool aSuspended );

    TBool IsSuspended();

    void ClearSessionFromJob( const CNSmlSOSSession* aSession );

    void ClosePendingMessages( const CNSmlSOSSession* aSession );

    void RegisterContactSuiteObserversWithProfileId(TInt aProfileId);

    TInt GetContactSuiteRegisteredProfileId() 

        {

        return iContactSuiteObserverProfileId;

        }

    TInt GetCurrentOngoingSessionProfileId()

        {

        if( iCurrentJob != NULL )

            return iCurrentJob->ProfileId();

        else

            return 0;

        }

public:

    // from MNSmlAlertObserver

	void CreateJobL( CNSmlAlertJobInfo& aJobInfo );

	void DoDisconnectL();	

    // from MSyncMLProgressObserver

    void OnSyncMLSyncError( TErrorLevel aErrorLevel, TInt aError, TInt aTaskId, TInt aInfo1, TInt aInfo2 );

    void OnSyncMLSyncProgress( TStatus aStatus, TInt aInfo1, TInt aInfo2 );		

    void OnSyncMLDataSyncModifications( TInt aTaskId, const TSyncMLDataSyncModifications& aClientMods,

                                                      const TSyncMLDataSyncModifications& aServerMods );

public:

	HBufC8* WriteSyncErrorL( TErrorLevel aErrorLevel, TInt aError, TInt aTaskId, TInt aInfo1, TInt aInfo2 );

	HBufC8* WriteSyncProgressL( TStatus aStatus, TInt aInfo1, TInt aInfo2 );

	HBufC8* WriteSyncModificationsL( TInt aTaskId, const TSyncMLDataSyncModifications& aClientMods,

                                                   const TSyncMLDataSyncModifications& aServerMods );

private:

    CNSmlSOSHandler();

    void ConstructL();

    TInt CreateJobId();

    void StartDSSyncL();

    void CancelDSSync();

    void StartDMSyncL();

    void CancelDMSync();

    void FinishCurrentJobL();

    TBool SearchSimilarJobs( const CNSmlJob* aJob );

    void ReadTasksFromDBL( RArray<TInt>& aArray );

    TSmlSyncType ReadSyncTypeForTaskL( const TInt aTaskId );

    void HandleEventMsg( MSyncMLEventObserver::TEvent, TInt status = 0 );

	CNSmlDbCaps::ENSmlSyncTypes ConvertSyncTypes(TSmlSyncType aSyncType);

    // from CActive

    void DoCancel();

    void RunL();

private:

    RArray<RMessage2> iProgressMsgs;

    RArray<RMessage2> iEventMsgs;

    RArray<RMessage2> iContactSuiteProgressMsgs;

    RArray<TInt> iProfileLocks;

	CNSmlJob* iCurrentJob;

    TInt iJobIndex;

    TInt iContactSuiteObserverProfileId;    

    RDesWriteStream iWrtStream;

    CNSmlMessageQueue* iMsgQueue;

	RLibrary iSessionLib;

    TInt iSessionCount;	

    TBool iSuspended;

	CNSmlThreadParams *iParams;

	CNSmlThreadObserver* iThreadObserver;

	};

/**

* An active class to follow system backup and restore state.

*  This class informs handler to suspend server when needed.

*

*  @since 

*/

class CNSmlSOSBackup : public CActive

	{

public:

    static CNSmlSOSBackup* NewL( CNSmlSOSHandler* aHandler );

	~CNSmlSOSBackup();

    void Subscribe();

private:    

	CNSmlSOSBackup( CNSmlSOSHandler* aHandler );

    void ConstructL();

    void RunL();

    void DoCancel();

	void BackUpModeL();

	void DeleteDataInRestoreL();

private:

    CNSmlSOSHandler* iHandler;

    RProperty iProperty;

    TBool iRestoring;

	};

/**

* A server class to intialize server and create sessions. 

*

*  @since 

*/

class CNSmlSOSServer : public CServer2

	{

public:

    static void PanicServer( TNSmlSOSServerPanic aPanic );

    static TInt ThreadFunction( TAny* aStarted );

    static CNSmlSOSServer* NewL();

	~CNSmlSOSServer();

public:

    CSession2* NewSessionL( const TVersion& aVersion, const RMessage2& aMessage ) const;

	CObjectCon* NewContainerL();

private:    

	CNSmlSOSServer();