/*

* Copyright (c) 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:  DS Sync flow

*

*/

#define SYNCML_V3

// INCLUDE FILES

#include <SyncMLHistory.h>

#include <e32property.h>

#include <DataSyncInternalPSKeys.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

// common includes with DM

#include "nsmlagenttestdefines.h"

#include "nsmlcliagconstants.h"

#include "NSmlAgentBase.h" 

#include "NSmlCmdsBase.h"

#include "NSmlStatusContainer.h"

#include "NSmlResponseController.h"

#include "NSmlURI.h"

#include "NSmlHistoryArray.h"

// DS specific includes

#include "nsmldsagconstants.h"

#include "NSmlDSAgent.h"

#include "NSmlDSCmds.h"

#include "nsmldscontent.h"

#include "nsmldserror.h"

#include "nsmldssettings.h"

#include "nsmlagentlog.h"

#include "nsmlroam.h"

//RD_AUTO_RESTART

#include <e32base.h>

#include <centralrepository.h> 

#include "SyncMLErr.h"

#include "nsmldsconstants.h"

//RD_AUTO_RESTART

_LIT( KNetMon,"\\netmon.exe" );

_LIT( KAutoRestart,"netmon" );

#ifndef __WINS__

// This lowers the unnecessary compiler warning (armv5) to remark.

// "Warning:  #174-D: expression has no effect..." is caused by 

// DBG_ARGS8 macro in no-debug builds.

#pragma diag_remark 174

#endif

// ============================ MEMBER FUNCTIONS ===============================

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

// CNSmlDSAgent::CNSmlDSAgent

// C++ constructor.

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

//

CNSmlDSAgent::CNSmlDSAgent()

    {

	}

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

// CNSmlDSAgent::ConstructL

// Symbian 2nd phase constructor.

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

//

void CNSmlDSAgent::ConstructL( MSyncMLProgressObserver* aDSObserver )

    {

    DBG_FILE(_S8("CNSmlDSAgent::ConstructL begins")); 

	CNSmlAgentBase::ConstructL();

	iDSObserver = aDSObserver;

	iDSContent = CNSmlDSContent::NewL();

	iError = new ( ELeave ) TNSmlDSError;

	iSyncMLMIMEType = KNSmlDSAgentMIMEType().AllocL();

	iResultAlertCode = KNSmlDSAgentResultAlert().AllocL();

	iNextMessageCode = KNSmlDSAgentNextMessage().AllocL();

	iEndOfDataAlertCode = KNSmlDSAgentNoEndOfData().AllocL();

	iUpdateLastAnchor=ETrue;

	//RD_AUTO_RESTART

	//Check whether the Auto Restart Feature is enabled or not 

	TInt keyVal;

	iAutoRestartInitiatedSync = EFalse;

	TRAPD (err ,ReadRepositoryL(KNsmlDsAutoRestart, keyVal));

	if(err==KErrNone && keyVal==1)

	{	

		iDSNetmon = CNsmlDSNetmon::NewL(*this);  

		DBG_FILE(_S8("CNSmlDSAgent::ConstructL DSNetmon is Launched"));

		CNsmlProfileUtil* profileUtil = CNsmlProfileUtil::NewLC();	

		profileUtil->IsValidResumeL(iAutoRestartInitiatedSync);	

		profileUtil->WriteInterruptFlagL(0);

		CleanupStack::PopAndDestroy(profileUtil);

	}

	else

	{

		iDSNetmon = NULL;

		DBG_FILE(_S8("CNSmlDSAgent::ConstructL DSNetmon is not Launched"));

	}

	//RD_AUTO_RESTART

	// security policies for P&S reading and writing

	_LIT_SECURITY_POLICY_S0( KNSmlPSWritePolicy, KNSmlSOSServerPolicyUID.iUid ); // SID check (sosserver) when writing

	_LIT_SECURITY_POLICY_PASS( KNSmlPSReadPolicy ); // no checks done when reading

	// Define P&S data field for sync ON/OFF flag (may fail e.g. if exists already)

	RProperty::Define( KPSUidDataSynchronizationInternalKeys, // category

                       KDataSyncStatus, // field

                       RProperty::EInt, // type

                       KNSmlPSReadPolicy, // read policy

                       KNSmlPSWritePolicy ); // write policy

	DBG_FILE(_S8("CNSmlDSAgent::ConstructL ends"));                        

	}

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

// CNSmlDSAgent::NewL

// Symbian two-phased constructor.

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

//

CNSmlDSAgent* CNSmlDSAgent::NewL( MSyncMLProgressObserver* aDSObserver )

    {

	CNSmlDSAgent* self = new (ELeave) CNSmlDSAgent();

	CleanupStack::PushL( self );

    self->ConstructL( aDSObserver );

	CleanupStack::Pop(); // self

    return self;

    }

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

// CNSmlDSAgent::~CNSmlDSAgent

// Destructor.

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

//

CNSmlDSAgent::~CNSmlDSAgent()

    {   

    delete iSyncLog;

	delete iDSContent;	

	delete iDSServerId;	

	delete iServerAlertPackage;

	if ( iDSSyncTypeArray )

		{	

		iDSSyncTypeArray->Reset();		

		delete iDSSyncTypeArray;

		}	

	//RD_AUTO_RESTART

	if(iDSNetmon)

	{

		delete iDSNetmon;		

		iDSNetmon = NULL;

	}	

	//RD_AUTO_RESTART	

	}

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

// CNSmlDSAgent::Synchronise

// Starts the sync, returns immediately and the initiated sync continues in the 

// RunL() function.

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

//

EXPORT_C void CNSmlDSAgent::Synchronise( TRequestStatus& aStatus,

		                      			 TSmlProfileId aProfileId,

		                      			 TSmlConnectionId aConnectionId,

							  			 CArrayFix<TNSmlContentSpecificSyncType>* aTypeArray,

							  			 TNSmlSyncInitiation aSyncInitiation,

							  			 TInt aSessionId,

							  			 HBufC8* aAlertPackage )

	{

	CActiveScheduler::Add( this );

	iCallerStatus = &aStatus;

	iSyncInitiation = aSyncInitiation;

	iProfileID = aProfileId;

	iMediumType.iUid = aConnectionId;

	iSessionId = aSessionId;

	*iCallerStatus = KRequestPending;

	TRAPD( err, PrepareSyncL( aTypeArray ) );

	if ( err != KErrNone )

		{

		DoErrorEvent( MSyncMLProgressObserver::ESmlFatalError, err, iDSContent->TaskId(), 0, 0 );

		User::RequestComplete( iCallerStatus, err );

		return;

		}

	if ( iSyncInitiation == EServerAlerted && aAlertPackage )

		{

		TRAP( err, iServerAlertPackage = aAlertPackage->AllocL() );

		if ( err != KErrNone )

			{

			DoErrorEvent( MSyncMLProgressObserver::ESmlFatalError, err, iDSContent->TaskId(), 0, 0 );

			User::RequestComplete( iCallerStatus, err );

			return;

			}

		}

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete( status, KErrNone );

	}

//

//  Private member functions

//

//

//  Begin state sub-functions 

//

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

// CNSmlDSAgent::BeginSubStartStateL()

// 

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

void CNSmlDSAgent::BeginSubStartStateL()

	{

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubStartStateL() begins"));

	iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlConnecting, 0, 0 );

	iDSCurrBeginSubState = EBeginSubReadSettings;

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubStartStateL() ends"));

	}

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

// CNSmlDSAgent::BeginSubReadSettingsStateL()

// 

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

void CNSmlDSAgent::BeginSubReadSettingsStateL()

	{

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubReadSettingsStateL() begins"));

	ReadSettingsL();

	iDSCurrBeginSubState = EBeginSubSyncmlCmdsInstance;

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubReadSettingsStateL() ends"));

	}

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

// CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL()

// 

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

void CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL()

	{

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL() begins"));

	CreateSyncmlCmdsInstanceL();

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL() ends"));

	iDSCurrBeginSubState = EBeginSubServerAlerting;

	}

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

// CNSmlDSAgent::BeginSubServerAlertingStateL()

// 

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

void CNSmlDSAgent::BeginSubServerAlertingStateL()

	{

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubServerAlertingStateL() begins"));

	if ( iSyncInitiation == TNSmlSyncInitiation( EServerAlerted ) )

		{

		DBG_FILE(_S8("CNSmlDSAgent::BeginSubServerAlertingStateL() Before ServerAlertStateL"));

		ServerAlertStateL();

		}

	iDSContent->InitAllSyncLogEventsL( *iSyncLog );

	iDSCurrBeginSubState = EBeginSubOpenContentInstances; 

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubServerAlertingStateL() ends"));

	}

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

// CNSmlDSAgent::BeginSubOpenContentInstancesStateL()

// 

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

void CNSmlDSAgent::BeginSubOpenContentInstancesStateL()

	{

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubOpenContentInstancesStateL() begins"));

	TBool endOfOpening = EFalse; 

	OpenDatabaseInstancesL( endOfOpening );

	if ( endOfOpening )

		{

		// <MAPINFO_RESEND_MOD_BEGIN>

		iDSCurrBeginSubState = EBeginSubScanMapInfo;

		// iDSCurrBeginSubState = EBeginSubCreateLUIDBuffers;

		// <MAPINFO_RESEND_MOD_END>

		}

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubOpenContentInstancesStateL() ends"));

	}

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

// CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL()

// 

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

void CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL()

	{

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL() begins"));

	TBool endOfCreating( EFalse );

	CreateLUIDBuffersL( endOfCreating );

	if ( endOfCreating )

		{

		iCurrBeginningState = EBeginConnectingToServer;

		}

	DBG_FILE(_S8("CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL() ends"));

	}

//

//  Server Alert state functions 

//

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

// CNSmlDSAgent::ServerAlertStateL

// Marks server alerted databases as alerted

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

//

void CNSmlDSAgent::ServerAlertStateL()	

	{

	// parse syncml 1.1 server alert package

	if ( iProtocolVer == ESmlVersion1_1_2 )

		{

		TPtr8 buffer( iSyncMLCmds->BufferAreaForParsingL() );

		if ( iServerAlertPackage->Length() > buffer.MaxLength() )

			{

			return;

			}

		buffer.Copy( *iServerAlertPackage );

		delete iServerAlertPackage;

		iServerAlertPackage = NULL;

		iDSCurrServerAlertState = EServerAlertWaitingStartMessage;

		while ( iSyncMLCmds->ProcessReceivedDataL() ) { }

		if ( iDSCurrServerAlertState != EServerAlertMessageReceived )

			{

			User::Leave( TNSmlError::ESmlIncompleteMessage );

			}

		}

	iDSContent->RemoveNotServerAlertedContents();

	if ( iProtocolVer == ESmlVersion1_2 )

		{

		if ( iDSContent->AllDatabasesAreInterrupted() )

			{

			if ( iError->SyncLogErrorCode() )

				{

				User::Leave( iError->SyncLogErrorCode() );

				}

			else

				{

				User::Leave( TNSmlDSError::ESmlDSNoValidDatabases );

				}

			}

		}

	}

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

// CNSmlDSAgent::ServerAlertStartMessageStateL

// Handles SyncHdr in Server Alert Package from server.

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

//

void CNSmlDSAgent::ServerAlertStartMessageStateL( SmlSyncHdr_t* aSyncHdr )

	{

	if ( iDSCurrServerAlertState != EServerAlertWaitingStartMessage )

		{

		User::Leave( TNSmlError::ESmlUnexpectedCmd ); 

		}

	iSyncMLCmds->ProcessSyncHdrL( aSyncHdr );

	iDSCurrServerAlertState = EServerAlertWaitingAlerts;

	}

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

// CNSmlDSAgent::ServerAlertAlertCmdStateL

// Handles Alert command in Server Alert Package from server.

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

//

void CNSmlDSAgent::ServerAlertAlertCmdStateL( SmlAlert_t* aAlert )

	{

	if ( iDSCurrServerAlertState != EServerAlertWaitingAlerts ) 

		{

		User::Leave( TNSmlError::ESmlUnexpectedCmd ); 

		}

	if ( iSyncMLCmds->AlertCode( aAlert ) == KNSmlAgentDisplayAlert )

		{

		iSyncMLCmds->ProcessAlertCmdL( aAlert, EFalse, EFalse, ETrue );

		}

	else

		{

		iSyncMLCmds->ProcessAlertCmdL( aAlert, EFalse, ETrue );

		}

	}

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

// CNSmlDSAgent::ServerAlertEndMessageStateL

// Processes the end of the alert command in server alert package.

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

//

void CNSmlDSAgent::ServerAlertEndMessageStateL( TBool /*aFinal*/ )

	{

	if ( iDSCurrServerAlertState != EServerAlertWaitingAlerts ) 

		{

		User::Leave( TNSmlError::ESmlUnexpectedCmd ); 

		}

	iDSCurrServerAlertState = EServerAlertMessageReceived;

	}

//

//  Client Initialisation state functions 

//

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

// CNSmlDSAgent::InitStartingMessageStateL()

// "Initialising" event to UI, initialises interruption flags

// set by possible first initialisation attempt, makes SyncHdr  

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

void CNSmlDSAgent::InitStartingMessageStateL()

	{

	iDSContent->InitInterruptionFlags();

	iDSContent->SetToFirst();

	InitStartingMessageStateBaseL();

	}

//RD_SUSPEND_RESUME	

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

// CNSmlDSAgent::MapAlertCode

// Maps the Alert code

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

// 

TPtrC8 CNSmlDSAgent::MapAlertCode(TNSmlPreviousSyncType aAlertCode)

{

   TPtrC8 prevAlert;

   if ( aAlertCode == ESyncDSTwoWay )

		{

		prevAlert.Set( KNSmlDSTwoWay);

		}

   else if ( aAlertCode == ESyncDSSlowSync)

		{

		prevAlert.Set(KNSmlDSSlowSync);

		}

   else if ( aAlertCode == ESyncDSOneWayFromClient)

		{

		prevAlert.Set(KNSmlDSOneWayFromClient);

		}

	else if ( aAlertCode == ESyncDSRefreshFromClient)

		{

		prevAlert.Set(KNSmlDSRefreshFromClient);

		}

	else if ( aAlertCode == ESyncDSOneWayFromServer  )

		{

		prevAlert.Set(KNSmlDSOneWayFromServer);

		}

	else if(aAlertCode ==ESyncDSRefreshFromServer )

	   {

		prevAlert.Set(KNSmlDSRefreshFromServer);

	   }		

	else if(aAlertCode ==ESyncDSTwoWayByServer )

	   {

		prevAlert.Set(KNSmlDSTwoWayByServer);

	   }   

    else if(aAlertCode ==ESyncDSOneWayFromClientByServer )

	   {

		prevAlert.Set(KNSmlDSOneWayFromClientByServer);

	   }

    else if(aAlertCode ==ESyncDSRefreshFromClientByServer )

	   {

		prevAlert.Set(KNSmlDSRefreshFromClientByServer);

	   }

    else if(aAlertCode ==ESyncDSOneWayFromServerByServer )

	   {

		prevAlert.Set(KNSmlDSOneWayFromServerByServer);

	   }

   else if(aAlertCode ==ESyncDSRefreshFromServerByServer )

	   {

		prevAlert.Set(KNSmlDSRefreshFromServerByServer);

	   }

  return(prevAlert);

}

//RD_SUSPEND_RESUME	

// CNSmlDSAgent::InitAlertingStateL

// Makes Alert command for each database. If there is a previously completed

// sync the client suggests two-way sync else slow sync is proposed.

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

//

void CNSmlDSAgent::InitAlertingStateL()

	{

	if ( iDSClientNextSyncAnchor == TTime( 0 ) )

		{

		 iDSClientNextSyncAnchor.UniversalTime();

		}

	if ( iDSContent->SetToFirst() )	

		{

		 do

			{		

			   TBuf8<3> syncType( iDSContent->SyncType() ); 

			   TTime clientLastSyncAnchor( iDSContent->LastSyncAnchorL() );

			   TNSmlPreviousSyncType prevSyncType=iDSContent->PreviousClientSyncTypeL();

			   iDSContent->SetSessionResumedL(EFalse);		   

			    if (!iDSContent->Interrupted())

				{