/*

* 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 <NSmlDMSync.rsg>

#include <aknnotewrappers.h>

#include <AknWaitDialog.h>

#include <textresolver.h>   // for CTextResolver

#include <StringLoader.h>

#include <e32property.h>

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

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

#include <AknsUtils.h>

#include <DevManInternalCRKeys.h>

#include <centralrepository.h>

#include "NSmlDMSyncDocument.h"

#include "NSmlDMSyncHandler.h"

#include "NSmlDMAuthQueryDlg.h"

#include "NSmlDMSyncState.h"

#include "NSmlDMSyncDebug.h"

#include "NSmlDMSyncDialog.h"

#include "nsmldmsyncinternalpskeys.h"

#include <nsmldmsync.mbg>

#include <featmgr.h>

#ifdef __SCALABLE_ICONS

_LIT( KBitmapFileName,  "z:nsmldmsync.mif" );

#else

_LIT( KBitmapFileName,  "z:nsmldmsync.mbm" );

#endif

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

// CNSmlDMSyncHandler::NewL

//

// Two-phased constructor.

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

//

CNSmlDMSyncHandler* CNSmlDMSyncHandler::NewL( RSyncMLSession* aSyncSession,

                                              CNSmlDMSyncAppEngine* aAppEngine,

                                              CNSmlDMSyncDocument* aSyncDocument )

    {

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

    CNSmlDMSyncHandler* self =

        new (ELeave) CNSmlDMSyncHandler( aSyncSession,

                                         aAppEngine,

                                         aSyncDocument );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CNSmlDMSyncHandler::~CNSmlDMSyncHandler()

    {

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

    if ( iFotaProgressDialog )

		{

	    TRAP_IGNORE( iFotaProgressDialog->CancelProgressDialogL() );

	    delete iFotaProgressDialog;

		}		            

	if ( iProgressDialog )

		{

	    TRAP_IGNORE( iProgressDialog->CancelProgressDialogL() );

	    delete iProgressDialog;

		}

	delete iState;

	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();   

	iState = CNSmlDMSyncState::NewL();

	iActiveCaller = CNSmlDMActiveCaller::NewL(this);

	iServerAlertedSync = EFalse;

	iSyncRunning = EFalse;

	iSyncError = KErrNone;

	iCheckUpdate = EFalse;

    }

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

// CNSmlDMSyncHandler::CNSmlDMSyncHandler

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

//

CNSmlDMSyncHandler::CNSmlDMSyncHandler( RSyncMLSession* aSyncSession,

                                        CNSmlDMSyncAppEngine* aAppEngine,

                                        CNSmlDMSyncDocument* aSyncDocument ) 

    : iSyncSession( aSyncSession ),

    iSyncAppEngine( aAppEngine ),

    iSyncDocument( aSyncDocument ),iFotaProgressLaunched(EFalse)

	{

	}

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

// CNSmlDMSyncHandler::HandleDialogEventL

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

//

void CNSmlDMSyncHandler::HandleDialogEventL( TInt aButtonId )

    {

    FLOG( "CNSmlDMSyncHandler::HandleDialogEventL" );

	if ( aButtonId == EEikBidCancel )

		{

		FLOG( "CNSmlDMSyncHandler::HandleDialogEventL cancelling" );

		if ( SyncRunning() )

			{

	        TInt err = RProperty::Set( KPSUidNSmlDMSyncApp,

				KDmJobCancel, KErrCancel );

	        FTRACE( FPrint(

	              _L("CNSmlDMSyncHandler::CancelSynchronizeL() KDmJobCancel = -3, err = %d"),

	                			err ) );

			FLOG( "CNSmlDMSyncHandler::HandleDialogEventL cancelling stop job" );

			TRAP_IGNORE( iSyncJob.StopL() );

		    State()->SetSyncPhase( CNSmlDMSyncState::EPhaseCanceling );

	        UpdateDialogL();

			}

		}

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

    }

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

// 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;  

	  _LIT_SECURITY_POLICY_S0( KWritePolicy, KUidSmlSyncApp.iUid );

        _LIT_SECURITY_POLICY_C1( KReadPolicy, ECapabilityReadDeviceData );

        RProperty::Define( KPSUidNSmlDMSyncApp,

                           KNSmlDMSyncUiInitiatedJobKey,

                           RProperty::EInt,

                           KReadPolicy,

                           KWritePolicy ); 

    RProperty::Set( KPSUidNSmlDMSyncApp,

                    KNSmlDMSyncUiInitiatedJobKey,

                    iSyncJobId );                       

	  //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();

    TInt dummyValue;

    TInt err = RProperty::Get( KPSUidNSmlDMSyncApp,

                               KNSmlDMSyncUiInitiatedJobKey,

                               dummyValue );

    if ( err == KErrNotFound )

        {

        _LIT_SECURITY_POLICY_S0( KWritePolicy, KUidSmlSyncApp.iUid );

        _LIT_SECURITY_POLICY_C1( KReadPolicy, ECapabilityReadDeviceData );

        RProperty::Define( KPSUidNSmlDMSyncApp,

                           KNSmlDMSyncUiInitiatedJobKey,

                           RProperty::EInt,

                           KReadPolicy,

                           KWritePolicy );

        }

    FTRACE( FPrint( _L(

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

	     iSyncJobId ) );    

    RProperty::Set( KPSUidNSmlDMSyncApp,

                    KNSmlDMSyncUiInitiatedJobKey,

                    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 );

		}

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

	TInt IsDMBusy = EFalse;   //IAD: Making DM Idle

	TInt r2=RProperty::Get(KUidSmlSyncApp,KDMIdle,IsDMBusy);

	if (IsDMBusy)

	   iNotinFotaView = 1;    //Not in fota view 

	else

	   iNotinFotaView = 0;    //already busy because in other view

	IsDMBusy =ETrue; 

  r2=RProperty::Set(KUidSmlSyncApp,KDMIdle,IsDMBusy);	   

	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 ) );

    // Error code can be ignored.

    RProperty::Set( KPSUidNSmlDMSyncApp,

                    KNSmlDMSyncUiInitiatedJobKey,

                    KNSmlDMNoUserInitiatedJob );

	iSyncRunning = EFalse;

	iSyncError = aError;

    iCheckUpdate = EFalse;

	// close progress dialog

	if ( iProgressDialog )

        {

        FLOG( "CNSmlDMSyncHandler::SynchronizeCompletedL close dialog" ); 

        iProgressDialog->CancelProgressDialogL();

        delete iProgressDialog;

        iProgressDialog = NULL;

        }

    if (  iFotaProgressDialog )

        {

        __ASSERT_ALWAYS( iSyncDocument, TUtil::Panic( KErrGeneral ) );

        iFotaProgressDialog->CancelProgressDialogL();

        TInt configFlags( EGenericSession );

        //TInt SetGenValue(0);

        CRepository* centrep = NULL;

        TRAPD( err, centrep = CRepository::NewL( KCRUidDeviceManagementInternalKeys ) );

        if ( centrep )

            {

            if( err == KErrNone )

             {

            centrep->Get( KDevManSessionType, configFlags );

             }

            delete centrep;

            } 

        /*if ( err != KErrNone ) 

            {

            User::Leave( err );

            }

        else

            {

            centrep->Set( KDevManSessionType, SetGenValue );

            }      

        if(centrep)    

           {

           delete centrep;

           }*/

        delete iFotaProgressDialog;

        iFotaProgressDialog = NULL;

        // configFlags=2 for FOTA Package not downloaded case ,1- successful download

        if ( !iSyncDocument->FwUpdStatesChangedL() && (aError == KErrNone) 

        				&& configFlags == EFotaPkgNotFound )

            {

            FLOG( "[OMADM]\t CNSmlDMSyncHandler::SynchronizeCompletedL(): No changes in FW Update states." );

            HBufC* stringHolder =

                StringLoader::LoadLC( R_QTN_FOTA_NO_NEW_UPDATES );

            CAknInformationNote* infoNote =

                new (ELeave) CAknInformationNote;

            infoNote->SetTimeout( CAknNoteDialog::ELongTimeout );

            // We are not interested in the result.

            infoNote->ExecuteLD( *stringHolder );

            CleanupStack::PopAndDestroy( stringHolder );

            }

        }  

	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 ) );

	if ( aEvent == EJobStop

	    || aEvent == EJobStartFailed

	    || aEvent == EJobRejected )

		{

    	FTRACE( FPrint( _L(

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

    	    iSyncJobId ) );

    	TInt value =EFalse; 

    	TInt r=RProperty::Get( KPSUidNSmlDMSyncApp, KFotaDLStatus, value );	  

    	FTRACE( FPrint(

					_L("KFotaDLStatus = %d"),r ) );  

    	if(!iNotinFotaView && value != 1 )    

        r =  RProperty::Set( KPSUidNSmlDMSyncApp,

				 			KDMIdle, KErrNone ); 

		if ( iSyncJobId == aIdentifier )

			{

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

			//For holding the DM Job session successful / error for future purpose

			TInt err =  RProperty::Set( KPSUidNSmlDMSyncApp,

							KDmJobCancel, KErrNone );   

			FTRACE( FPrint(

					_L("KDmJobCancel setting in OnSyncMLSessionEvent err = %d"),err ) );

            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 ) );

	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:

		    State()->SetSyncPhase( CNSmlDMSyncState::EPhaseSynchronizing );

		    break;

		case ESmlDisconnected:

		    State()->SetSyncPhase( CNSmlDMSyncState::EPhaseDisconnecting );

		    break;

		case ESmlCompleted:

		    State()->SetSyncPhase( CNSmlDMSyncState::EPhaseDisconnecting );

		    break;

		case ESmlProcessingServerCommands:

		    State()->SetSyncPhase( CNSmlDMSyncState::EPhaseSending );

		    break;

		case ESmlReceivingServerCommands:

		    State()->SetSyncPhase( CNSmlDMSyncState::EPhaseReceiving );

		    break;

		case ESmlSendingModificationsToServer:

		    {

		    if( iFotaProgressDialog && iCheckUpdate == EFalse )

		    {

		    State()->SetSyncPhase( CNSmlDMSyncState::EPhaseFinal );	

		    }

		    break;

		    }

		default:

		    break;

		}