/*

* 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:  SyncML DM command handling 

*

*/

// INCLUDE FILES

#include <SyncMLObservers.h>

#include <SyncMLHistory.h>

#include <PolicyEngineClient.h>

#include <centralrepository.h>

#include "PMUtilInternalCRKeys.h"

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmlunicodeconverter.h>

// DM specific includes

#include <nsmldmmodule.h>

// common includes with DS

#include "nsmlcliagconstants.h"

#include "NSmlAgentBase.h" 

#include "NSmlCmdsBase.h"

#include "NSmlStatusContainer.h"

#include "NSmlResultsContainer.h"

#include "NSmlResponseController.h"

#include "NSmlAuth.h"

#include "NSmlURI.h"

#include "nsmlagenttestdefines.h"

// DM specific includes

#include "nsmldmagconstants.h"

#include "NSmlDMAgent.h"

#include "NSmlDMCmds.h"

#include "nsmldmsettings.h"

#include "nsmldmerror.h"

#include "NSmlHistoryArray.h"

// FOTA

#include "NSmlDMGenericAlert.h"

#include "NSmlPrivateAPI.h"

// FOTA end

#include <featmgr.h>

const TInt KNotifierTimeout = 300000000; // 5 min timeout

_LIT8 ( KNSmlDMFotaNode, "FUMO" );

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

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

// CNSmlDMAgent::NewL()

// Creates new instance of CNSmlDMAgent. 

// Does not leave instance pointer to CleanupStack.

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

//

CNSmlDMAgent* CNSmlDMAgent::NewL( MSyncMLProgressObserver* aDMObserver )

    {

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

    CleanupStack::PushL( self );

	self->ConstructL( aDMObserver );

	CleanupStack::Pop();

    return self;

    }

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

// CNSmlDMAgent::~CNSmlDMAgent()

// Destructor

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

//

CNSmlDMAgent::~CNSmlDMAgent()

    {

	delete iDMTriggerMessage;

	delete iDMServerId;

	delete iDMServerPassword;

	delete iDMServerDigest;

	delete iSyncLog;

	// FOTA

	iGenAlerts.ResetAndDestroy();

	iGenAlerts.Close();

	// FOTA end	

if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))

{

	delete iNotifierObserver;

}

FeatureManager::UnInitializeLib();

	}

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

// CNSmlDMAgent::Configure()

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

// in RunL() function 

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

//

void CNSmlDMAgent::Configure( TRequestStatus& aStatus,TInt aProfileId,TInt aTransportId,TNSmlSyncInitiation aSyncInitiation,TInt aIapId)

 	{

	DBG_FILE(_S8("CNSmlDMAgent::Configure"));

	CActiveScheduler::Add(this);

	iProfileID = aProfileId;

	iMediumType.iUid = aTransportId;

	iSyncInitiation = aSyncInitiation;

	iCallerStatus = &aStatus;

	iNewIapId = aIapId;

	*iCallerStatus = KRequestPending;

	TRAPD(leaveCode,iSyncLog = CSyncMLHistoryJob::NewL());

	if(leaveCode!=KErrNone)

		{

		User::RequestComplete( iCallerStatus, leaveCode );

		return;

		}

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete( status, KErrNone );

	}

// FOTA

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

// CNSmlDMAgent::SetGenericAlertL()

//	Appends a Generic Alert to the internal list. 

//	The alert itself is sent in the later phase of the dm session.

//	@param aFwMgmtUri. The uri which has been used in the exe command whose final result is 

//	about to be reported.

//	@param aMetaType. Meta/Type that should be used in the alert.

//	@param aMetaFormat. Meta/Format that should be used in the alert.

//	@param aFinalResult. The final result value which is reported to remote server.

//	@param aCorrelator. Correlator value used in the original exec command. 

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

//

void CNSmlDMAgent::SetGenericAlertL ( const TDesC8& aFwMgmtUri, const TDesC8& aMetaType, const TDesC8& aMetaFormat, 

						TInt aFinalResult, const TDesC8& aFwCorrelator )

	{

	CNSmlDMGenericAlert* genAlert = CNSmlDMGenericAlert::NewL ( aFwMgmtUri, aMetaType, aMetaFormat, aFinalResult, aFwCorrelator );

	iGenAlerts.AppendL ( genAlert );	

	}

// FOTA end

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

// CNSmlDMAgent::SetGenericAlertL()

//	Appends a Generic Alert to the internal list. 

//	The alert itself is sent in the later phase of the dm session.

//	@param aFwMgmtUri. The uri which has been used in the exe command whose final result is 

//	about to be reported.

//	@param aMetaType. Meta/Type that should be used in the alert.

//	@param aMetaFormat. Meta/Format that should be used in the alert.

//	@param aFinalResult. The final result value which is reported to remote server.

//	@param aCorrelator. Correlator value used in the original exec command. 

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

//

void CNSmlDMAgent::SetGenericAlertL ( const TDesC8& aCorrelator, const RArray<CNSmlDMAlertItem>& aItemList  )

    {

    CNSmlDMGenericAlert* genAlert = CNSmlDMGenericAlert::NewL ( aCorrelator, aItemList );

    iGenAlerts.AppendL ( genAlert );	

    }

//

//  Private member functions

//

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

// CNSmlDMAgent::CNSmlDMAgent()

// Constructor

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

//

CNSmlDMAgent::CNSmlDMAgent()

	{

	}

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

// CNSmlDMAgent::ConstructL()

// Two-way construction. Constructor may leave in EPOC.

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

//

void CNSmlDMAgent::ConstructL( MSyncMLProgressObserver* aDMObserver )

    {

	CNSmlAgentBase::ConstructL();

	iDMObserver = aDMObserver;

	iError = new (ELeave) TNSmlDMError;

	iSyncMLMIMEType = KNSmlDMAgentMIMEType().AllocL();

	iResultAlertCode = KNSmlDMAgentResultAlert().AllocL();

	iNextMessageCode = KNSmlDMAgentNextMessage().AllocL();

	//Session Abort Alert is used because there is no "End of Data Alert" in DM specs

	iEndOfDataAlertCode = KNSmlDMAgentSessionAbortAlert().AllocL(); 

	iSessionAbortAlertCode = KNSmlDMAgentSessionAbortAlert().AllocL();

	FeatureManager::InitializeLibL();

	iNewIapId = KErrNotFound;

	}

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

// CNSmlDMAgent::SupportedAlert()

// Check from code if supported Alert  

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

TBool CNSmlDMAgent::SupportedAlert( const TDesC8& aAlertCode ) const

{

if ( aAlertCode == KNSmlDMAgentServerInitAlert ||

        aAlertCode == KNSmlDMAgentClientInitAlert ||

        aAlertCode == KNSmlDMAgentResultAlert ||

        aAlertCode == KNSmlDMAgentNextMessage ||

        aAlertCode == KNSmlDMAgentSessionAbortAlert ||

        aAlertCode == KNSmlDMAgentDisplayAlert ||

		{

		return ETrue;

		}

	return EFalse;

	}

//

//  Server Modifications state functions 

//

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

// CNSmlDMAgent::ServerModificationsStateL(()

// Main state function to read both Initialization from server client package

// and Further server management operations package  

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

void CNSmlDMAgent::ServerModificationsStateL()

    {

    _DBG_FILE(_S8("CNSmlDMAgent::ServerModificationsStateL begins"));

    // FOTA

    if ( !iChallengeRequest )

        {

        if ( iResetGenAlerts )

            {

            // Forward information to FOTA adapter if 1.1.2 otherwise any adapter 

            //which has sent GenAlert should be informed

            // It can now mark GenAlerts sent.

            if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))

                {

                for ( TInt i(0); i<iGenAlerts.Count(); i++ )

                    {

                    if(iGenAlerts[i]->FinalResult() != 0)

                        {

                        iSyncMLCmds->MarkGenAlertsSentL(*iGenAlerts[i]->FwMgmtUri());    											

                        if(iGenAlerts[i]->FwMgmtUri()->Des().Find(KNSmlDMFotaNode)!=KErrNotFound)

                            {

                            iResetUserInitAlert= ETrue;	

                            }

                        }

                    else

                        {

                        // Generic alerts could be present for other adapters like SCOMO

                        iSyncMLCmds->MarkGenAlertsSentL(*(*iGenAlerts[i]->DataItem())[0].iSource);

                        }

                    }

                }

            else

                {

                iSyncMLCmds->MarkGenAlertsSentL();		

                }

            iResetGenAlerts = EFalse;

            iGenAlerts.ResetAndDestroy();

            }

        if ( iResetUserInitAlert )

            {

            iSyncMLCmds->ResetGenericUserAlertL();

            iResetUserInitAlert = EFalse;

            }

        }

    // FOTA end	

    if ( !iSyncMLCmds->ProcessReceivedDataL() )

        {

        DBG_FILE(_S8("CNSmlDMAgent::ServerModificationsStateL end of Data"));

        if ( iCurrServerModState == EServerModMessageReceived )

            {

            iBusyStatusReceived = iSyncMLCmds->BusyStatus();

            }

        else

            {

            if ( iCurrServerModState != EServerModPackageReceived )

                {

                User::Leave( TNSmlError::ESmlIncompleteMessage );

                }

            }

        iSyncMLCmds->EndOfServerMessageL();

        NextMainStateL();

        }

    //DBG_FILE(_S8("CNSmlDMAgent::ServerModificationsStateL ends"));

    }

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

// CNSmlDMAgent::ServerModGetCmdStateL()

// 

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

void CNSmlDMAgent::ServerModGetCmdStateL( SmlGet_t* aContent )

	{

	DBG_FILE(_S8("CNSmlDMAgent::ServerModGetCmdStateL begins"));

	if ( iCurrServerModState != EServerModWaitingCommands )

		{

		User::Leave( TNSmlError::ESmlUnexpectedCmd ); 

		}

	iSyncMLCmds->ProcessGetCmdL( aContent );	

	DBG_FILE(_S8("CNSmlDMAgent::ServerModGetCmdStateL ends"));

	}

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

// CNSmlDMAgent::ServerModStartAtomicStateL()

// 

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

void CNSmlDMAgent::ServerModStartAtomicStateL( SmlAtomic_t* aContent )

	{

	DBG_FILE(_S8("CNSmlDMAgent::ServerModStartAtomicStateL begins"));

	if ( iCurrServerModState != EServerModWaitingCommands )

		{

		User::Leave( TNSmlError::ESmlUnexpectedCmd ); 

		}

	if ( iNestedAtomicsCount > 0 )

		{

		iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentAtomic, aContent->cmdID, aContent->flags );

		WriteWarningL( TNSmlError::ESmlUnexpectedCmd );

		}

	else

		{

		iSyncMLCmds->ProcessAtomicL( aContent );

		}

	++iNestedAtomicsCount;

	DBG_FILE(_S8("CNSmlDMAgent::ServerModStartAtomicStateL ends"));

	}

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

// CNSmlDMAgent::ServerModEndAtomicStateL()

// 

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

void CNSmlDMAgent::ServerModEndAtomicStateL()

	{

	DBG_FILE(_S8("CNSmlDMAgent::ServerModEndAtomicStateL begins"));

	--iNestedAtomicsCount;

	if ( iNestedAtomicsCount == 0 )

		{

		iSyncMLCmds->ProcessEndAtomicL();

		}

	DBG_FILE(_S8("CNSmlDMAgent::ServerModEndAtomicStateL ends"));

	}

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

// CNSmlDMAgent::ServerModStartSequenceStateL()

// 

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

void CNSmlDMAgent::ServerModStartSequenceStateL( SmlSequence_t* aContent )

	{

	DBG_FILE(_S8("CNSmlDMAgent::ServerModStartSequenceStateL begins"));

	if ( iCurrServerModState != EServerModWaitingCommands )

		{

		User::Leave( TNSmlError::ESmlUnexpectedCmd ); 

		}

	else

		{

		iSyncMLCmds->ProcessSequenceL( aContent );

		}

	DBG_FILE(_S8("CNSmlDMAgent::ServerModStartSequenceStateL ends"));

	}

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

// CNSmlDMAgent::ServerModEndSequenceStateL()

// 

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

void CNSmlDMAgent::ServerModEndSequenceStateL()

	{

	DBG_FILE(_S8("CNSmlDMAgent::ServerModEndSequenceStateL begins"));

	iSyncMLCmds->ProcessEndSequence();

	DBG_FILE(_S8("CNSmlDMAgent::ServerModEndSequenceStateL ends"));

	}

//

//  Finishing state functions 

//

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

// CNSmlDMAgent::FinishingStateL()

// Finishing functions in the end of sync

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

void CNSmlDMAgent::FinishingStateL()

	{

	DBG_FILE(_S8("CNSmlDMAgent::FinishingStateL begins"));

	FinishL();  

	TRAP_IGNORE( FinalizeSyncLogL());

	DBG_FILE(_S8("CNSmlDMAgent::FinishingStateL ends"));

	}

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

// CNSmlDMAgent::ReadSettingsL()

// Reads settings for the DM session

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

void CNSmlDMAgent::ReadSettingsL()

	{

	CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );

	if ( !profile )

		{

		User::Leave( TNSmlError::ESmlErrorInSettings );

		}

	else

		{

		CleanupStack::PushL( profile );

		if( iNewIapId > KErrNotFound )

			{

			DBG_FILE_CODE(iIAPId,_S8("CNSmlDMAgent::ReadSettingsL not using profiles IAP:"));	

			iIAPId = iNewIapId;

			}

		else

			{

			DBG_FILE_CODE(iIAPId,_S8("CNSmlDMAgent::ReadSettingsL using profiles IAP"));	

    		iIAPId = profile->IntValue( EDMProfileIAPId );

			}

		iIAPIdArray = new (ELeave) CArrayFixFlat<TUint32>(4);

		iIAPIdArray->AppendL( iIAPId );

		iSyncMLUserName = profile->StrValue( EDMProfileServerUsername ).AllocL();

		iSyncMLPassword = profile->StrValue( EDMProfileServerPassword ).AllocL();

		iSyncHTTPAuthUsed = profile->IntValue( EDMProfileHttpAuthUsed );	

		iSyncHTTPAuthUserName = profile->StrValue( EDMProfileHttpAuthUsername ).AllocL();	

		iSyncHTTPAuthPassword = profile->StrValue( EDMProfileHttpAuthPassword ).AllocL();	

		if ( iMediumType ==  KUidNSmlMediumTypeInternet )

			{

			iSyncServer= CNSmlURI::NewL( profile->StrValue( EDMProfileServerURL ), ETrue );

			}

		else

			{

			iSyncServer= CNSmlURI::NewL( profile->StrValue( EDMProfileServerURL ), EFalse );

			}

		iDMServerId = profile->StrValue( EDMProfileServerId ).AllocL();

		iDMServerPassword = profile->StrValue( EDMProfileClientPassword ).AllocL();

		iDMServerSessionId = profile->IntValue( EDMProfileSessionId );

		CleanupStack::PopAndDestroy( 2 ); //profile, settings

		}

	}

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

// CNSmlDMAgent::InitSyncLogL()

// Sync Log (shown In UI) initilisation in the beginning of sync

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

void CNSmlDMAgent::InitSyncLogL()

	{

	CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );

	if ( profile )

		{

		CleanupStack::PushL( profile );

		TTime now;

		now.HomeTime();

		CleanupStack::PopAndDestroy(2); //profile, settings

		}

	else

		{

		CleanupStack::PopAndDestroy(); //settings

		}

	}

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

// CNSmlDMAgent::GetSessionIDL()

// Gets SessionID from Agent Log

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

TInt CNSmlDMAgent::GetSessionIDL()

	{

	CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );

	TInt sessionID = 0;

	if ( !profile )

		{

		User::Leave( TNSmlError::ESmlErrorInSettings );

		}

	else

		{

		CleanupStack::PushL( profile );

		sessionID = profile->IntValue( EDMProfileSessionId );  

		CleanupStack::PopAndDestroy( 2 ); //profile, settings

		}

	return sessionID;

	}

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

// CNSmlDMAgent::UpdateSessionIDL()

// Updates SessionID in Agent Log

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

void CNSmlDMAgent::UpdateSessionIDL( TInt aSessionID )

	{

	CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );

	if ( !profile )

		{

		User::Leave( TNSmlError::ESmlErrorInSettings );

		}

	else

		{

		CleanupStack::PushL( profile );

		profile->SetIntValue( EDMProfileSessionId, aSessionID );

		profile->SaveL();

		CleanupStack::PopAndDestroy( 2 ); //profile, settings

		}

	}

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

// CNSmlDMAgent::FinishL()

// 

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

void CNSmlDMAgent::FinishL()

	{

	iSyncMLCmds->WriteMappingInfoToDbL();

	iSyncMLCmds->DisconnectFromOtherServers();

	if ( Interrupted() )

		{

		iDMObserver->OnSyncMLSyncError(MSyncMLProgressObserver::ESmlFatalError,iError->SyncLogErrorCode(),0,0,0);

		User::RequestComplete( iCallerStatus, iError->SyncLogErrorCode() );

		}

	else

		{

		iDMObserver->OnSyncMLSyncProgress(MSyncMLProgressObserver::ESmlCompleted,0,0);

		User::RequestComplete( iCallerStatus, KErrNone );

		}

	iEnd = ETrue;

	}

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

// CNSmlDMAgent::InterruptedImmediately()

// 

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

TBool CNSmlDMAgent::InterruptedImmediately()

	{

	return iDMImmediatelyInterruption;

	}