/*

* 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 <e32property.h>

#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

const TInt KRequestTriggerWaitTime(1000);

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

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

    }

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

// StaticSynchronizeRequestL() called to start Synchronization

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

static TInt StaticSynchronizeRequestL(TAny* aPtr)

    {

    CNSmlDMSyncHandler* ptr = (CNSmlDMSyncHandler*) aPtr;

    FLOG("StaticSynchronizeRequestL");   

    TRAPD(err, ptr->StartSynchronizeL() );  

    FLOG("StaticSynchronizeRequestL completed");

    return err;

    }

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

// CNSmlDMSyncHandler::SynchronizeL

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

//

void CNSmlDMSyncHandler::SynchronizeL( TDesC& aServerName,

                                       const TInt aProfileId,

                                       const TInt aJobId,

                                       const TInt aConnectionBearer,

                                       const TBool aUseFotaProgressNote, 

                                       const TBool aSilent)

	{

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

	iServerName = aServerName;

	iConnectionBearer = aConnectionBearer;

    iProfileId = aProfileId;

    iJobId = aJobId;

    iUseFotaProgressNote = aUseFotaProgressNote;

    iSilent = aSilent;

    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::StartSynchronizeL

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

//

void CNSmlDMSyncHandler::StartSynchronizeL()

    {

    FLOG( "CNSmlDMSyncHandler::StartSynchronizeL" );

    if(iPeriodic)

       {

       delete iPeriodic;

       iPeriodic = NULL;

       FLOG("CNSmlDMSyncHandler::iPeriodic-deleted");

       }

    const TUid KDisclaimerProperty = {0x101F8769};

    const TUint32 KInteger = 0x00000001;

    TInt propValue;

    TInt err = KErrNone;

    if(iSilent == EFalse)   //disclaimer shown for non silent session

        {

        if(TUtil::ShowNativeDialogL(EPrivacyPolicy)==KErrNone)

            {

            TRAP( err, ShowProgressDialogL() );

            if ( err != KErrNone )

                {

                Session().CancelEvent();

                Session().CancelProgress();

                iSyncJob.StopL();

                iSyncJob.Close();

                propValue = 0;

                RProperty::Set(KDisclaimerProperty, KInteger, propValue);

                User::Leave( err );

                }

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

            // Publish key here; set to 1

            propValue = 1;

            RProperty::Set(KDisclaimerProperty, KInteger, propValue);

            }

        else

            {

            Session().CancelEvent();

            Session().CancelProgress();

            propValue = 0;

            RProperty::Set(KDisclaimerProperty, KInteger, propValue);            

            }

        }

    else    //for silent session, disclaimer not shown

        {

        TRAP( err, ShowProgressDialogL() );

        if ( err != KErrNone )

            {

            Session().CancelEvent();

            Session().CancelProgress();

            iSyncJob.StopL();

            iSyncJob.Close();

            propValue = 0;

            RProperty::Set(KDisclaimerProperty, KInteger, propValue);

            User::Leave( err );

            }

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

            // Publish key here; set to 1

         propValue = 1;

         RProperty::Set(KDisclaimerProperty, KInteger, propValue);

        }

     iSyncDocument->MarkFwUpdChangesStartL();

     iSyncRunning = ETrue;

     iSyncError = KErrNone;

     FLOG( "CNSmlDMSyncHandler::StartSynchronizeL completed" );

    }

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

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

	if(iServerAlertedSync)

		{

        iPeriodic = CPeriodic::NewL (EPriorityNormal) ;

        FLOG("CNSmlDMSyncHandler::SynchronizeL: iPeriodic created)");

        iPeriodic->Start(TTimeIntervalMicroSeconds32(KRequestTriggerWaitTime*20)

                  , TTimeIntervalMicroSeconds32(KRequestTriggerWaitTime*2500)

                  , TCallBack(StaticSynchronizeRequestL,this) ) ;

		}

	else

	    {//For user initiated session

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