/*

* Copyright (c) 2002-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:  Methods for CNSmlDMSyncDocument

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <eikenv.h>

#include <centralrepository.h>

#include <SyncMLNotifierDomainCRKeys.h>

#include <e32const.h>

#include <DevManInternalCRKeys.h>

#include <e32property.h>

#include "nsmldmsyncinternalpskeys.h"

#include "NSmlDMSyncApp.h"

#include "NSmlDMSyncAppEngine.h"

#include "NSmlDMSyncDocument.h"

#include "NSmlDMSyncAppUi.h"

#include "NSmlDMSyncProfileList.h"

#include "NSmlDMSyncProfile.h"

#include "NSmlDMSyncDebug.h"

#include <NSmlDMSync.rsg>

#include <SyncService.h>

#include <SyncServiceParams.h>

#include <coreapplicationuisdomainpskeys.h>

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

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

// Desctructor

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

//

CNSmlDMSyncDocument::~CNSmlDMSyncDocument()

    {

    FLOG( "[OMADM] CNSmlDMSyncDocument::~CNSmlDMSyncDocument" );

    TInt err = RProperty::Delete(KPSUidNSmlDMSyncApp,KServerAlertType);

    FTRACE( FPrint(

            _L("CNSmlDMSyncDocument::~CNSmlDMSyncDocument KServerAlertType key deletion with error err = %d"),err ) );

   //IAD****

   err = RProperty::Delete(KPSUidNSmlDMSyncApp, KDMIdle);         

    err = RProperty::Delete(KPSUidNSmlDMSyncApp, KFotaDLRefresh);

    FTRACE( FPrint(

            _L("CNSmlDMSyncDocument::~CNSmlDMSyncDocumentKFotaDLRefresh key deletion with error err = %d"),err ) );

    err = RProperty::Delete(KPSUidNSmlDMSyncApp, KDmJobCancel);

    err = RProperty::Delete(KPSUidNSmlDMSyncApp, KSilentSession);

    FTRACE( FPrint(

            _L("CNSmlDMSyncDocument::~CNSmlDMSyncDocument KDmJobCancel key deletion with error err = %d"),err ) );

    delete iDbNotifier;

    delete iSyncProfileList;

	delete iAppEngine;

	if ( iProfileList )

	    {

	    iProfileList->Reset();

	    delete iProfileList;

	    }

    delete iServer;

    }

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

// CNSmlDMSyncDocument::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNSmlDMSyncDocument::ConstructL()

    {

    FLOG( "[OMADM] CNSmlDMSyncDocument::ConstructL" );

    iAppEngine = CNSmlDMSyncAppEngine::NewL( this );

    iSyncProfileList = CNSmlDMSyncProfileList::NewL( iAppEngine );

    iSilent = EFalse;

    iDbEventsBlocked = EFalse;

    iDbNotifier = CNSmlDMDbNotifier::NewL( iAppEngine->Session(), this );

    iDbNotifier->RequestL();

    iProfileList = new (ELeave) CArrayFixFlat< TNSmlDMProfileItem >(1);

    iCurrentIndex = 0;

    iEikEnv = CEikonEnv::Static();

    iOldProfileId = KErrNotFound;

    //SAN Spport

    TInt SanSupport( KErrNone );

    CRepository* centrep = NULL;

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

    if( err == KErrNone )

       {

    centrep->Get( KDevManSANUIBitVariation, SanSupport );

       }

    delete centrep;

    iSanSupport = SanSupport;

        _LIT_SECURITY_POLICY_S0( KWritePolicy, KUidSmlSyncApp.iUid );

        _LIT_SECURITY_POLICY_C1( KReadPolicy, ECapabilityReadDeviceData );

        _LIT_SECURITY_POLICY_C1( KWritePolicy1, ECapabilityWriteDeviceData );

        RProperty::Define( KPSUidNSmlDMSyncApp,

                           KServerAlertType,

                           RProperty::EInt,

                           KReadPolicy,

                           KWritePolicy );

     RProperty::Set( KPSUidNSmlDMSyncApp,

                				    KServerAlertType,

                    				KErrNotFound );   	

	err  = RProperty::Define( KPSUidNSmlDMSyncApp,

			KFotaDLRefresh,

			RProperty::EInt,KReadPolicy,KWritePolicy1); 

	TInt err1 = KErrNotFound;

	//if key defined then only set from DMUI, other wise fota sets it

	if( err == KErrNone ) 

		{

		iDMDefinesFotaDLKey = ETrue;

		err1 =      RProperty::Set( KPSUidNSmlDMSyncApp,

				KFotaDLRefresh,KErrNone );    		 

		}

	FTRACE( FPrint(

			_L("KFotaDLRefresh setting err = %d, err1 = %d"),err, err1 ) );

//IAD ******//

err  = RProperty::Define( KPSUidNSmlDMSyncApp,

			KDMIdle,

			RProperty::EInt); 

err1 =  RProperty::Set( KPSUidNSmlDMSyncApp,

			KDMIdle,KErrNone );

 if (err1)

 {

  FTRACE( FPrint(

			_L("error in setting = %d, err1 = %d"),err, err1 ) );			

 }			 

FTRACE( FPrint(

			_L("KDMIdle setting err = %d, err1 = %d"),err, err1 ) );			

			KFotaDLStatus,

	err1 =  RProperty::Set( KPSUidNSmlDMSyncApp,

    FLOG( "[OMADM] CNSmlDMSyncDocument::ConstructL() completed" );

	err  = RProperty::Define( KPSUidNSmlDMSyncApp,

			KDmJobCancel,

			RProperty::EInt,KReadPolicy,KWritePolicy1); 

	err1 =  RProperty::Set( KPSUidNSmlDMSyncApp,

			KDmJobCancel, KErrNone );   

	// Define new P&S key to know whether these DM session started in Silent or

	// User Interactive mode

	RProperty::Define( KPSUidNSmlDMSyncApp,

                           KSilentSession,

                           RProperty::EInt);

	FTRACE( FPrint(

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

    FLOG( "[OMADM] CNSmlDMSyncDocument::ConstructL() completed" );

    }

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

// CNSmlDMSyncDocument::NewL

// Two-phased constructor.

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

//

CNSmlDMSyncDocument* CNSmlDMSyncDocument::NewL( CAknApplication& aApp )

    {

    FLOG( "[OMADM] CNSmlDMSyncDocument::NewL:" );

	CNSmlDMSyncDocument* self = new (ELeave) CNSmlDMSyncDocument( aApp );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();  //self

    FLOG( "[OMADM] CNSmlDMSyncDocument::NewL() completed" );

    return self;

	}

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

// CNSmlDMSyncDocument::CreateAppUiL

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

//

CEikAppUi* CNSmlDMSyncDocument::CreateAppUiL()

    {

    FLOG( "[OMADM] CNSmlDMSyncDocument::CreateAppUiL:" );

	return new (ELeave) CNSmlDMSyncAppUi;

	}

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

// CNSmlDMSyncDocument::DeleteProfile

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

//

TInt CNSmlDMSyncDocument::DeleteProfile( TInt& aIndex )

	{

    FTRACE( FPrint(

        _L("[OMADM] CNSmlDMSyncDocument::DeleteProfile(), index = %d"),

        aIndex ) );

    TInt retVal = KErrNotFound;

	if ( iProfileList->Count() <= 0 )

		{

		return retVal;

		}

	TRAP( retVal, iAppEngine->DeleteProfileL( 

	                            (*iProfileList)[iCurrentIndex].iProfileId ) );

	if ( retVal == KErrNone )

		{

		TRAP( retVal, ReadProfileListL() );

    	if ( retVal == KErrNone )

    		{		

    		if ( iCurrentIndex > iProfileList->Count() - 1 )

    			{

    			iCurrentIndex--;

    			}

    		aIndex = iCurrentIndex;

    		}

		}

    FTRACE( FPrint(

        _L("[OMADM] CNSmlDMSyncDocument::DeleteProfile() completed, retval = %d, index = %d"),

        retVal, iCurrentIndex ) );

	return retVal;

	}

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

// CNSmlDMSyncDocument::ReadProfileListL

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

//

void CNSmlDMSyncDocument::ReadProfileListL()

	{

	ReadProfileListL( EFalse );

	}

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

// CNSmlDMSyncDocument::ReadProfileListL

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

//

void CNSmlDMSyncDocument::ReadProfileListL( TBool aIncludeHidden )

	{

	FLOG( "[OMADM] CNSmlDMSyncDocument::ReadProfileListL:" );

	iProfileList->Reset();

	TKeyArrayFix key(_FOFF( TNSmlDMProfileItem, iProfileName ), ECmpFolded16 );

	iProfileList->Sort(key);

    iSyncProfileList->Reset();

	TRAPD( error, iSyncProfileList->ReadProfileItemsL( aIncludeHidden ) );

	if ( error != KErrNone )

	    {

	    iSyncProfileList->Reset();

	    }

	//read profile values

	for ( TInt index = 0; index < iSyncProfileList->Count(); index++ )

		{

	    TNSmlDMProfileItem profile;

		profile.iProfileName = iSyncProfileList->Item( index ).iProfileName;

		if ( profile.iProfileName.Length() == 0 )

			{

			StringLoader::Load( profile.iProfileName, R_QTN_APPS_EMPTYPROFILE );

			}		

    	profile.iProfileId   = iSyncProfileList->Item( index ).iProfileId;

		profile.iBearer		 = iSyncProfileList->Item( index ).iBearer;

		profile.iSynced      = iSyncProfileList->Item( index ).iSynced;

		profile.iLastSync	 = iSyncProfileList->Item( index ).iLastSync;

		profile.iLastSuccessSync	 = iSyncProfileList->Item( index ).iLastSuccessSync;

		profile.iActive		 = iSyncProfileList->Item( index ).iActive;

        profile.iDeleteAllowed =  iSyncProfileList->Item( index ).iDeleteAllowed;

        profile.iProfileLocked =  iSyncProfileList->Item( index ).iProfileLocked;

		TInt start = 0;

		TBool found( EFalse );

		if ( iProfileList->Count() == 0 )

			{

			iProfileList->AppendL ( profile );		

			}

		else

			{

			while ( ( start < iProfileList->Count() ) && ( !found ) )

				{

				if ( iAppEngine->Compare( profile.iProfileName,

				     iProfileList->At( start ).iProfileName ) < 1 )

					{

					iProfileList->InsertL( start, profile );

					found = ETrue;

					}

				start++;

				}

			if ( !found ) //insert to the end of the list

				{

				iProfileList->AppendL( profile );

				}

			}

		}

	FLOG( "[OMADM] CNSmlDMSyncDocument::ReadProfileListL() completed" );

	}

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

// CNSmlDMSyncDocument::ProfileItem

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

//

TNSmlDMProfileItem* CNSmlDMSyncDocument::ProfileItem() const

	{

    FTRACE( FPrint(

        _L("[OMADM] CNSmlDMSyncDocument::ProfileItem() iProfileList = 0x%x"),

        iProfileList ) );

	if ( iProfileList->Count() > 0 )

		{

		return &( *iProfileList )[ iCurrentIndex ];

		}

	return 0;

	}

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

// CNSmlDMSyncDocument::ProfileItemAt

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

//

TNSmlDMProfileItem* CNSmlDMSyncDocument::ProfileItemAt( TInt aIndex ) const

	{

	FLOG( "[OMADM] CNSmlDMSyncDocument::ProfileItemAt:" );

	if ( ( iProfileList->Count() > 0 ) &&

	   ( ( aIndex >= 0 ) &&

	   ( aIndex < iProfileList->Count() ) ) )

		{

		return &( *iProfileList )[aIndex];

		}

	return 0;

	}

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

// CNSmlDMSyncDocument::FotaModel

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

//

CNSmlDMFotaModel* CNSmlDMSyncDocument::FotaModel() const

    {

    return ((CNSmlDMSyncAppUi*) iAppUi)->FotaModel();

    }

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

// CNSmlDMSyncDocument::MarkFwUpdChangesStartL

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

//

void CNSmlDMSyncDocument::MarkFwUpdChangesStartL()

    {

    ((CNSmlDMSyncAppUi*) iAppUi)->MarkFwUpdChangesStartL();

    }

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

// CNSmlDMSyncDocument::FwUpdStatesChangedL

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

//

TBool CNSmlDMSyncDocument::FwUpdStatesChangedL()

    {

    return ((CNSmlDMSyncAppUi*) iAppUi)->FwUpdStatesChangedL();

    }

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

// CNSmlDMSyncDocument::ProfileList

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

//

CArrayFixFlat< TNSmlDMProfileItem >* CNSmlDMSyncDocument::ProfileList( 

                                                                  TInt& aIndex )

	{

	FLOG( "[OMADM] CNSmlDMSyncDocument::ProfileList:" );

	if ( iCurrentIndex < 0 )

		{

		iCurrentIndex = 0;

		}

	aIndex = iCurrentIndex; 

	FLOG( "[OMADM] CNSmlDMSyncDocument::ProfileList() completed" );

	return iProfileList; 

	}

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

// CNSmlDMSyncDocument::SetCurrentIndex

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

//

void CNSmlDMSyncDocument::SetCurrentIndex( TInt aIndex ) 

	{

	FLOG( "[OMADM] CNSmlDMSyncDocument::SetCurrentIndex:" );

	if ( ( aIndex > -1 ) && ( aIndex < iProfileList->Count() ) )

		{

		iCurrentIndex = aIndex; 

		}

    FTRACE( FPrint(

        _L("[OMADM] CNSmlDMSyncDocument::SetCurrentIndex() completed, index = %d"),

        iCurrentIndex ) );

	}

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

//  CNSmlDMSyncDocument::MoveIndexToProfile

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

//

void CNSmlDMSyncDocument::MoveIndexToProfile( TInt aProfileId )

	{

    FTRACE( FPrint(

        _L("[OMADM] CNSmlDMSyncDocument::MoveIndexToProfile(), aProfileId = %d"),

        aProfileId ) );

	TInt index = 0;

	TRAP_IGNORE( ReadProfileListL() );//new fix for the error  ELGO-6ZK8BD

	TInt profileCount = iProfileList->Count();

	while ( ( index < profileCount ) &&

	      ( (*iProfileList)[index].iProfileId != aProfileId ) )

		{

		index++;

		}

	if ( index < profileCount )

		{

		SetCurrentIndex( index );

		}

	else //Fix for SMAN-73XGBM

		{

		SetCurrentIndex( 0 );	

		}

    FTRACE( FPrint(

        _L("[OMADM] CNSmlDMSyncDocument::MoveIndexToProfile() completed, index = %d"),

        index ) );

	}

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

// CNSmlDMSyncDocument::GetCopyProfileL

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

//

void CNSmlDMSyncDocument::GetCopyProfileL( TInt& aProfileId )

	{

	FLOG( "[OMADM] CNSmlDMSyncDocument::GetCopyProfileL:" );

	if ( iProfileList->Count() <= 0 )

		{

		return;

		}

	// save the original profileid, if it's not saved it can be deleted

	iOldProfileId = ( *iProfileList )[iCurrentIndex].iProfileId;

	CNSmlDMSyncProfile* profile = 

	  iAppEngine->CreateCopyProfileL( (*iProfileList )[iCurrentIndex].iProfileId );

    profile->SetNameL( GetNextProfileNameLC()->Des() );

	aProfileId = profile->ProfileId();

	profile->SaveL();

	iAppEngine->CloseProfile();

	CleanupStack::PopAndDestroy(); //name

	FLOG( "[OMADM] CNSmlDMSyncDocument::GetCopyProfileL() completed" );

	}

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

// CNSmlDMSyncDocument::GetNextProfileNameLC

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

HBufC* CNSmlDMSyncDocument::GetNextProfileNameLC()

	{

	FLOG( "[OMADM] CNSmlDMSyncDocument::GetNextProfileNameLC:" );

	TBool newNameFound = EFalse;

	HBufC* profileName = NULL;

	TInt nameIndex = 1;

	while ( !newNameFound )

		{

		profileName = StringLoader::LoadLC( R_QTN_APPS_NEWPROFILE, nameIndex );

		TNSmlDMProfileItem profileItem;

		profileItem.iProfileName = *profileName;

		TKeyArrayFix key(_FOFF(TNSmlDMProfileItem, iProfileName), ECmpFolded16 );

		TInt foundIndex;

		if ( iProfileList->Find( profileItem, key, foundIndex ) )

			{

			newNameFound = ETrue;

			}

		else

			{

			nameIndex++;

			CleanupStack::PopAndDestroy( profileName );

			}

		}

    FTRACE( FPrint(

        _L("[OMADM] CNSmlDMSyncDocument::GetNextProfileNameLC() completed, name = \"%S\""),

        profileName ) );

	return profileName;

	}

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

// DisableDbNotifications

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

//

void CNSmlDMSyncDocument::DisableDbNotifications( TBool aEvent )

    {

    iDbEventsBlocked = aEvent;

    }

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

// HandleDbEventL

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

//

void CNSmlDMSyncDocument::HandleDbEventL( TNSmlDMDbEvent aEvent )

	{

	FLOG( "[OMADM] CNSmlDMSyncDocument::HandleDbEventL:" );