/*

* 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: Implementation of DM UI component

* 	This is part of omadmappui.

*

*/

// INCLUDES

#include <textresolver.h>   // for CTextResolver

#include <e32property.h>

#include <data_caging_path_literals.hrh>  // for resource and bitmap directories

#include <SyncMLErr.h>      // sync error codes

#include <DevManInternalCRKeys.h>

#include <centralrepository.h>

#include <featmgr.h>

#include "nsmldmsynchandler.h"

#include "nsmldmsyncdebug.h"

#include "nsmldmsyncinternalpskeys.h"

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

// CNSmlDMSyncHandler::NewL

//

// Two-phased constructor.

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

//

CNSmlDMSyncHandler* CNSmlDMSyncHandler::NewL( RSyncMLSession* aSyncSession,

                                              CNSmlDMSyncAppEngine* aAppEngine )

    {

	FLOG( "CNSmlDMSyncHandler::NewL()" );

    CNSmlDMSyncHandler* self =

        new (ELeave) CNSmlDMSyncHandler( aSyncSession,

                                         aAppEngine);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CNSmlDMSyncHandler::~CNSmlDMSyncHandler()

    {

    FLOG( "CNSmlDMSyncHandler::~CNSmlDMSyncHandler()" );     

	delete iActiveCaller;

	if ( iSyncRunning )

	    {

	    TRAP_IGNORE( iSyncJob.StopL() );

        iSyncJob.Close();

	    }

	  FeatureManager::UnInitializeLib();

	FLOG( "CNSmlDMSyncHandler::~CNSmlDMSyncHandler() completed" );

    }

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

// CNSmlDMSyncHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNSmlDMSyncHandler::ConstructL( void )

    {

    FLOG( "CNSmlDMSyncHandler::ConstructL" );

   FeatureManager::InitializeLibL();   	

	iActiveCaller = CNSmlDMActiveCaller::NewL(this);

	iServerAlertedSync = EFalse;

	iSyncRunning = EFalse;

	iSyncError = KErrNone;	

	iCheckUpdate = EFalse;	

    }

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

// CNSmlDMSyncHandler::CNSmlDMSyncHandler

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

//

CNSmlDMSyncHandler::CNSmlDMSyncHandler( RSyncMLSession* aSyncSession,

                                        CNSmlDMSyncAppEngine* aAppEngine) 

    : iSyncSession( aSyncSession ),

    iSyncAppEngine( aAppEngine )   

	{

	}

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

// CNSmlDMSyncHandler::SynchronizeL

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

//

void CNSmlDMSyncHandler::SynchronizeL( TDesC& aServerName,

                                       const TInt aProfileId,

                                       const TInt aJobId,

                                       const TInt aConnectionBearer,

                                       const TBool aUseFotaProgressNote )

	{

	FLOG( "CNSmlDMSyncHandler::SynchronizeL Server alert" );

	iServerName = aServerName;

	iConnectionBearer = aConnectionBearer;

    iProfileId = aProfileId;

    iJobId = aJobId;

    iUseFotaProgressNote = aUseFotaProgressNote;

    iSyncJob.OpenL( Session(), iJobId );

    iSyncJobId = iSyncJob.Identifier();

    FTRACE( FPrint( _L(

	    "[OMADM]\tCNSmlDMSyncHandler::SynchronizeL--server alert, iSyncJobId = %d" ),

	     iSyncJobId ) ); 

	  //SAN Support

	  iServerAlertedSync = ETrue;  

	  //SAN Support

    SynchronizeL();

	}

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

// CNSmlDMSyncHandler::SynchronizeL

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

//

void CNSmlDMSyncHandler::SynchronizeL( TDesC& aServerName,

                                       const TInt aProfileId,

                                       const TInt aConnectionBearer,

                                       const TBool aUseFotaProgressNote )

    {

    FLOG( "CNSmlDMSyncHandler::SynchronizeL" );

    iServerName = aServerName;

    iConnectionBearer = aConnectionBearer;

    iProfileId = aProfileId;

    iUseFotaProgressNote = aUseFotaProgressNote;

    iSyncJob.CreateL( Session(), iProfileId );

    iSyncJobId = iSyncJob.Identifier();

    SynchronizeL();

    FTRACE( FPrint( _L(

	    "[OMADM]\tCNSmlDMSyncHandler::SynchronizeL--UI initiated, iSyncJobId = %d" ),

	     iSyncJobId ) );       

	}

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

// CNSmlDMSyncHandler::SynchronizeL

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

//

void CNSmlDMSyncHandler::SynchronizeL()

	{

	FLOG( "CNSmlDMSyncHandler::SynchronizeL" );

	TInt err = KErrNone;

	// for MSyncMLEventObserver events

	TRAP( err, Session().RequestEventL(*this) );

	if ( err != KErrNone )

		{

		iSyncJob.StopL();

		iSyncJob.Close();

		User::Leave(err);

		}

    // for MSyncMLProgressObserver events

    TRAP( err, Session().RequestProgressL(*this) );

	if ( err != KErrNone )

		{

		Session().CancelEvent();

		iSyncJob.StopL();

		iSyncJob.Close();

		User::Leave( err );

		}

	TRAP( err, ShowProgressDialogL() );

	if ( err != KErrNone )

		{

		Session().CancelEvent();

		Session().CancelProgress();

		iSyncJob.StopL();

		iSyncJob.Close();

		User::Leave( err );

		}

	FLOG( "CNSmlDMSyncHandler::SynchronizeL Sync is running" );

    //iSyncDocument->MarkFwUpdChangesStartL();

	iSyncRunning = ETrue;

	iSyncError = KErrNone;

	}

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

// CNSmlDMSyncHandler::SynchronizeCompletedL

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

//

void CNSmlDMSyncHandler::SynchronizeCompletedL( TInt aError )

	{

    FTRACE( FPrint(

        _L("[OMADM]\t CNSmlDMSyncHandler::SynchronizeCompletedL(), aError = %d"),

        aError ) );

	if ( !SyncRunning() )

		{

		FLOG( "CNSmlDMSyncHandler::SynchronizeCompletedL already completed" );

		return;  // sync has already completed

		}

    iSyncJob.Close();

     FTRACE( FPrint( _L(

	    "[OMADM]\tCNSmlDMSyncHandler::SynchronizecompletedL, iSyncJobId = %d" ),

	     KNSmlDMNoUserInitiatedJob ) );

	iSyncRunning = EFalse;

	iSyncError = aError;    

    iCheckUpdate = EFalse;        	

	iUseFotaProgressNote = EFalse;

    iSyncJob.Close();

	// handle error in HandleActiveCallL (when active caller completes)

	iActiveCaller->Start( aError );

	FLOG( "CNSmlDMSyncHandler::SynchronizeCompletedL() completed" );

	}

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

// CNSmlDMSyncHandler::OnSyncMLSessionEvent

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

//

void CNSmlDMSyncHandler::OnSyncMLSessionEvent( TEvent aEvent,

                                               TInt aIdentifier,

                                               TInt aError,

                                               TInt /*aAdditionalData*/ )

	{

	FTRACE( FPrint( _L(

	    "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent(), aEvent = %d, aIdentifier = %d, aError = %d" ),

	    aEvent, aIdentifier, aError ) );

	FTRACE( RDebug::Print( _L(

	    "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent(), aEvent = %d, aIdentifier = %d, aError = %d" ),

	    aEvent, aIdentifier, aError ) );

	if ( aEvent == EJobStop

	    || aEvent == EJobStartFailed

	    || aEvent == EJobRejected )

		{

    	FTRACE( RDebug::Print( _L(

    	    "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent(), iSyncJobId = %d" ),

    	    iSyncJobId ) );

    	  FTRACE( FPrint( _L(

    	    "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent(), iSyncJobId = %d" ),

    	    iSyncJobId ) );  

		if ( iSyncJobId == aIdentifier )

			{

			FLOG( "CNSmlDMSyncHandler::OnSyncMLSessionEvent EJobStop close" );

            TRAP_IGNORE( SynchronizeCompletedL( aError ) );

			}

		}

    FLOG( "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent() completed" );

    }

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

// CNSmlDMSyncHandler::OnSyncMLSyncError

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

//

void CNSmlDMSyncHandler::OnSyncMLSyncError( TErrorLevel aErrorLevel,

                                            TInt aError,

                                            TInt /*aTaskId*/,

                                            TInt /*aInfo1*/,

                                            TInt /*aInfo2*/)

	{

	FTRACE( FPrint( _L(

	    "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSyncError(), aErrorLevel = %d, aError = %d"),

	    aErrorLevel, aError ) );

	    FTRACE( RDebug::Print(

	          _L("CNSmlDMSyncHandler::OnSyncMLSyncProgress  aErrorLevel =(%d) aError =(%d)"), aErrorLevel, aError  ) );

	if ( aErrorLevel == ESmlFatalError )

		{

        TRAP_IGNORE( SynchronizeCompletedL( aError ) );

		}

    FLOG( "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSyncError() completed" );

	}

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

// CNSmlDMSyncHandler::OnSyncMLSyncProgress

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

//

void CNSmlDMSyncHandler::OnSyncMLSyncProgress( TStatus aStatus,

                                               TInt /*aInfo1*/,

                                               TInt /*aInfo2*/ )

	{

	FTRACE( RDebug::Print(

	          _L("CNSmlDMSyncHandler::OnSyncMLSyncProgress (%d)"), aStatus ) );

	switch (aStatus)

		{

		case ESmlConnecting:

		    //State()->SetSyncPhase( CNSmlDMSyncState::EPhaseConnecting );

		    break;

		case ESmlConnected:

		    break;

		case ESmlLoggingOn:

		    break;

		case ESmlLoggedOn:

		    break;

		case ESmlDisconnected:

		    break;

		case ESmlCompleted:

		    break;

		case ESmlProcessingServerCommands:

		    break;

		case ESmlReceivingServerCommands:

		    break;

		case ESmlSendingModificationsToServer:

		    {		   		    

		    break;

		    }

		default:

		    break;

		}    

	}

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

// CNSmlDMSyncHandler::OnSyncMLDataSyncModifications

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

//

void CNSmlDMSyncHandler::OnSyncMLDataSyncModifications( TInt /*aTaskId*/,

                   const TSyncMLDataSyncModifications& /*aClientModifications*/,

                   const TSyncMLDataSyncModifications& /*aServerModifications*/ )

    {

    FLOG( "CNSmlDMSyncHandler::OnSyncMLDataSyncModifications" );

    }

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

// CNSmlDMSyncHandler::HandleActiveCallL

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

//

void CNSmlDMSyncHandler::HandleActiveCallL()

	{

    FLOG( "CNSmlDMSyncHandler::HandleActiveCallL" );

    // HandleSyncErrorL will set this to true if

    // sync will be retried.

    iRetrySync = EFalse;

	if ( (iSyncError != KErrNone) && (iSyncError != KErrCancel) )

		{

		TRAP_IGNORE( HandleSyncErrorL() );

		}

	if ( iRetrySync == EFalse )

		{

	    // Inform parent that sync is done.

	    iSyncAppEngine->SyncCompleted( ENSmlSyncComplete );		

		}

	}

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

// CNSmlDMSyncHandler::HandleSyncErrorL

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

//

void CNSmlDMSyncHandler::HandleSyncErrorL()

	{

	FLOG( "CNSmlDMSyncHandler::HandleSyncErrorL" );

	if ( iSyncError != KDMErr )

		{

		}

	if ( ( iSyncError == SyncMLError::KErrAuthenticationFailure ) ||

	    ( iSyncError == SyncMLError::KErrTransportAuthenticationFailure ) )

        {

	    FLOG( "CNSmlDMSyncHandler::HandleSyncErrorL ask username" );

        }

    }

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

// CNSmlDMSyncHandler::ShowProgressDialogL

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

//

void CNSmlDMSyncHandler::ShowProgressDialogL( )

	{

	FLOG( "CNSmlDMSyncHandler::ShowProgressDialogL" );

	FLOG( "CNSmlDMSyncHandler::ShowProgressDialogL() completed" );

	}

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

// CNSmlDMSyncHandler::HideProgressDialogL

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

//

void CNSmlDMSyncHandler::HideProgressDialogL()

    {

    FLOG( "CNSmlDMSyncHandler::HideProgressDialogL" );

    }

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

// CNSmlDMSyncHandler::Session

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

//

RSyncMLSession& CNSmlDMSyncHandler::Session()

	{

	__ASSERT_DEBUG(iSyncSession, TUtil::Panic(KErrGeneral));

	return *iSyncSession;

	}

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

// CNSmlDMSyncHandler::SyncRunning

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

//

TBool CNSmlDMSyncHandler::SyncRunning()

	{

	FTRACE( RDebug::Print(

	          _L("CNSmlDMSyncHandler::SyncRunning status (%d)"), iSyncRunning ) );

	return iSyncRunning;

	}

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

// CNSmlDMSyncHandler::CancelSynchronizeL

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

//		

void CNSmlDMSyncHandler::CancelSynchronizeL()

    {

    FLOG( "CNSmlDMSyncHandler::CancelSynchronizeL" );

    if ( iSyncRunning )

        {

        iSyncJob.StopL();

        SynchronizeCompletedL( KErrCancel );

        }

    }

// End of File