/*

* 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:  Database (content) specific fata and functionality

*

*/

// INCLUDE FILES

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include "nsmldbcaps.h"

#include <nsmlchangefinder.h>

#include "nsmldserror.h"

#include "nsmlcliagconstants.h"

#include "nsmldscontent.h"

#include "NSmlDSCmds.h"

#include "nsmldsluidbuffer.h"

#include "nsmldsmapcontainer.h"

#include "nsmlagentlog.h"

#include "NSmlURI.h"

#include "nsmldshostclient.h"

#include "NsmlDSContentItem.h"

#include "nsmldssettings.h"

#include <centralrepository.h> 

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

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

// CNSmlDSContent::CNSmlDSContent()

// C++ default constructor.

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

//

CNSmlDSContent::CNSmlDSContent()

	{

	}

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

// CNSmlDSContent::ConstructL

// Symbian 2nd phase constructor.

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

//

void CNSmlDSContent::ConstructL()

	{

// <MAPINFO_RESEND_MOD_BEGIN>

	SetMapStreamUID();

	iOldMapExists=EFalse;

	TInt keyVal;

	TRAPD (err ,ReadRepositoryL(KNsmlDsSuspendResume, keyVal));

	if(err==KErrNone && keyVal==1)

		{

		SetResendUsed(ETrue);	

		}

	else

		{

		SetResendUsed(EFalse);	

		}

// <MAPINFO_RESEND_MOD_END>

	}

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

// CNSmlDSContent::NewL

// Symbian two-phased constructor.

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

//

CNSmlDSContent* CNSmlDSContent::NewL()

	{

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	return( self );

	}

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

// CNSmlDSContent::~CNSmlDSContent

// Destructor.

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

//

CNSmlDSContent::~CNSmlDSContent()

	{

	iStores.ResetAndDestroy();		

	iStores.Close();

	delete iOldServerId;

	delete iHostClient;

	iHierarchicalSupportTable.ResetAndDestroy();

	iHierarchicalSupportTable.Close();

	}

void CNSmlDSContent::InitContentDataL()

	{

	iHostClient = CNSmlDSHostClient::NewL();

	}

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

// CNSmlDSContent::CurrentIndex

// Returns the index of the current content (datastore). 

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

//

TInt CNSmlDSContent::CurrentIndex() const

	{

	return iIndex;

	}

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

// CNSmlDSContent::ContentIndexIsSet

// Checks whether some content is selected.

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

//

TBool CNSmlDSContent::ContentIndexIsSet() const

	{

	if ( iIndex == -1 )

		{

		return EFalse;

		}

	return ETrue;

	}

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

// CNSmlDSContent::Count

// Returns the number of contents in the content array.

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

//

TInt CNSmlDSContent::Count() const

	{

	return iStores.Count();

	}

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

// CNSmlDSContent::ImplementationUID

// Returns current content's unique identifier.

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

//

TInt CNSmlDSContent::ImplementationUID() const

	{

	return iStores[iIndex]->iImplementationUID;

	}

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

// CNSmlDSContent::LocalDatabase()

// 

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

CNSmlURI* CNSmlDSContent::LocalDatabase() const

	{

	return iStores[iIndex]->iLocalDatabase;

	}

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

// CNSmlDSContent::RemoteDatabase()

// 

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

CNSmlURI* CNSmlDSContent::RemoteDatabase() const

	{

	return iStores[iIndex]->iRemoteDatabase;

	}

//RD_SUSPEND_RESUME

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

// CNSmlDSContent::SyncType

// Returns the datastore's currently selected synchronisation type.

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

//

TPtrC8 CNSmlDSContent::SyncType() const

	{

	if ( iStores[iIndex]->iSyncType )

		{

		return iStores[iIndex]->iSyncType->Des();		

		}

	return TPtrC8( KNullDesC8 );

	}

//RD_SUSPEND_RESUME

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

// CNSmlDSContent::ClientSyncType

// Returns the Sync Type proposed by the Client in the Sync session

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

//

TPtrC8 CNSmlDSContent::ClientSyncType() 

	{

		if ( iStores[iIndex]->iClientSyncType )

		{

		  	return iStores[iIndex]->iClientSyncType->Des();

		}

	return TPtrC8( KNullDesC8 );

	}

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

// CNSmlDSContent::SupportsOperationL

// Checks if an operation is supported by the data provider.

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

//

TBool CNSmlDSContent::SupportsOperationL( TUid aOperation )

	{

	TInt resultCode;

// <MAPINFO_RESEND_MOD_BEGIN>

	if( aOperation == KUidSmlSupportBatch && ResendUsed() ) 

		{

		return EFalse;	

		}

// <MAPINFO_RESEND_MOD_END>

	return iHostClient->SupportsOperationL( aOperation, iStores[iIndex]->iImplementationUID, resultCode );

	}

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

// CNSmlDSContent::BeginTransActionL

// Sets the current datastore to the transaction mode.

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

//

void CNSmlDSContent::BeginTransActionL()

	{

	TInt resultCode;

	iStores[iIndex]->iAtomicModeOn = ETrue;

	iHostClient->BeginTransactionL( iStores[iIndex]->iImplementationUID, *iStores[iIndex]->iStoreName, resultCode );

	}

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

// CNSmlDSContent::CommitTransactionL

// Orders the current datastore to apply pending atomic operations.

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

//

void CNSmlDSContent::CommitTransactionL( TInt& aResultCode )

	{

	iStores[iIndex]->iAtomicModeOn = EFalse;

	iHostClient->CommitTransactionL( iStores[iIndex]->iImplementationUID, *iStores[iIndex]->iStoreName, aResultCode );

	}

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

// CNSmlDSContent::RevertTransactionL

// Aborts the ongoing transaction.

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

//

void CNSmlDSContent::RevertTransactionL( TInt& aResultCode )

	{

	iStores[iIndex]->iAtomicModeOn = EFalse;

	iHostClient->RevertTransactionL( iStores[iIndex]->iImplementationUID, *iStores[iIndex]->iStoreName, aResultCode );

	}

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

// CNSmlDSContent::AtomicModeOn

// Checks if the current datastore is in the batch mode.

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

//

TBool CNSmlDSContent::AtomicModeOn() const

	{

	return iStores[iIndex]->iAtomicModeOn;

	}

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

// CNSmlDSContent::OpenNextItemL

// Opens the next item in the LUID buffer.

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

//

TInt CNSmlDSContent::OpenNextItemL( TSmlDbItemUid& aLocalUid, TSmlDbItemUid& aParentUid, TDes8& aCmdName, TInt& aSize, CNSmlDbMeta& aMeta ) const

	{

	TInt ret( iStores[iIndex]->iLUIDBuffer->NextUIDL( aLocalUid, aCmdName ) );

	if ( ( ret == KErrNone ) && ( aCmdName != KNSmlAgentDelete ) )

		{

		TBool fieldChange;

		HBufC8* mimeType;

		HBufC8* mimeVersion;

		iHostClient->OpenItemL( aLocalUid,

								fieldChange, 

								aSize, 

								aParentUid,

								mimeType, 

								mimeVersion, 

								iStores[iIndex]->iImplementationUID, 

								*iStores[iIndex]->iStoreName, 

								ret );

		if ( ret == KErrNone )			

			{

			CleanupStack::PushL( mimeType );

			CleanupStack::PushL( mimeVersion );

			if ( fieldChange )

				{

				aCmdName = KNSmlAgentPartialReplace;			

				}

			aMeta.SetTypeL( *mimeType );

			aMeta.SetVersionL( *mimeVersion );

			CleanupStack::PopAndDestroy( 2 ); // mimeVersion, mimeType

			}

		}		

	return ret;

	}

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

// CNSmlDSContent::ReadItemL

// Reads data from the currently open item.

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

//

void CNSmlDSContent::ReadItemL( TDes8& aBuffer )

	{

	TInt resultCode;

	iHostClient->ReadItemL( aBuffer, iStores[iIndex]->iImplementationUID, *iStores[iIndex]->iStoreName, resultCode );

	}

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

// CNSmlDSContent::CloseItemL

// Closes the currently open item.

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

//

void CNSmlDSContent::CloseItemL()

	{

	TInt resultCode;

	iHostClient->CloseItemL( iStores[iIndex]->iImplementationUID, *iStores[iIndex]->iStoreName, resultCode );

	}	

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

// CNSmlDSContent::CurrentUID

// Returns the UID of the current item. 

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

//

void CNSmlDSContent::CurrentUID( TSmlDbItemUid& aLocalUID ) const

	{

	iStores[iIndex]->iLUIDBuffer->CurrentUID( aLocalUID );

	}

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

// CNSmlDSContent::DbCapabilitiesL()

// 

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

TInt CNSmlDSContent::DbCapabilitiesL( CNSmlDbCaps*& aDbCaps ) const

	{

	TInt resultCode( KErrNone );

	aDbCaps = iHostClient->StoreFormatL( iStores[iIndex]->iImplementationUID, resultCode );

	return resultCode;

	}

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

// CNSmlDSContent::HasSyncHistoryL

// Checks if the current datastore has been synced previously.

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

//

TBool CNSmlDSContent::HasSyncHistoryL() const

	{

	TInt resultCode;

	return iHostClient->HasSyncHistoryL( iStores[iIndex]->iImplementationUID, *iStores[iIndex]->iStoreName, resultCode );

	}

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

// CNSmlDSContent::IsSupportedRxL

// Checks if the given RxType is supported by the datastore.

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

//

TBool CNSmlDSContent::IsSupportedRxL( const TDesC8& aType ) const

	{

	TBool ret( EFalse );

	CNSmlDbCaps* dbCaps;

	TInt result = DbCapabilitiesL( dbCaps );

	User::LeaveIfError( result );

	CleanupStack::PushL( dbCaps );

	// dbCaps ownership is moved to a caller

	SmlDevInfDatastore_t*  datastore = dbCaps->DatastoreL();

	if ( !datastore )

		{

		CleanupStack::PopAndDestroy(); // dbCaps

		return ret;

		}

	// datastore ownership is moved to a caller

	CleanupStack::PushL( datastore );

	if ( aType == datastore->rxpref->cttype->Data() )

		{

		ret = ETrue;

		}

	else

		{

		SmlDevInfXmitList_t* rxList = datastore->rx;

		while ( rxList )

			{

			if ( aType == rxList->data->cttype->Data() )

				{

				ret = ETrue;

				break;

				}

			rxList = rxList->next;

			}

		}

	CleanupStack::PopAndDestroy( 2 ); // datastore, dbCaps

	return ret;

	}

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

// CNSmlDSContent::IsSupportedTxL

// Checks if the given TxType is supported by the datastore.

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

//

TBool CNSmlDSContent::IsSupportedTxL( const TDesC8& aType ) const

	{

	TBool ret = EFalse;

	CNSmlDbCaps* dbCaps;

	TInt result = DbCapabilitiesL( dbCaps );	

	User::LeaveIfError( result );

	CleanupStack::PushL( dbCaps );

	// dbCaps ownership is moved to a caller

	SmlDevInfDatastore_t*  datastore = dbCaps->DatastoreL();

	if ( !datastore )

		{

		CleanupStack::PopAndDestroy(); // dbCaps

		return ret;

		}

	// datastore ownership is moved to a caller

	CleanupStack::PushL( datastore );

	if ( aType == datastore->txpref->cttype->Data() )

		{

		ret = ETrue;

		}

	else

		{

		SmlDevInfXmitList_t* txList = datastore->tx;

		while ( txList )

			{

			if ( aType == txList->data->cttype->Data() )

				{

				ret = ETrue;

				break;

				}

			txList = txList->next;

			}

		}

	CleanupStack::PopAndDestroy( 2 ); // datastore, dbCaps

	return ret;

	}

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

// CNSmlDSContent::IsSupportedSyncTypeL()

// 

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

TBool CNSmlDSContent::IsSupportedSyncTypeL( CNSmlDbCaps::ENSmlSyncTypes aSyncType ) const

	{

	CNSmlDbCaps* dbCaps( NULL );

	TInt result = DbCapabilitiesL( dbCaps );

	User::LeaveIfError( result );

	TBool ret( dbCaps->SupportsSyncType( aSyncType ) );

	delete dbCaps;

	return ret;

	}

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

// CNSmlDSContent::IsSupportedSyncTypeL()

// 

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

TBool CNSmlDSContent::IsSupportedSyncTypeL( const TDesC8& aSyncType ) const

	{

	CNSmlDbCaps::ENSmlSyncTypes syncType;

	if ( SyncTypeConv ( aSyncType, syncType ) )

		{

		return IsSupportedSyncTypeL( syncType );

		}

	return EFalse;

	}

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

// CNSmlDSContent::IsHierarchicalSyncSupportedL()

// 

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

TBool CNSmlDSContent::IsHierarchicalSyncSupportedL( const TPtr8 aMediaType ) 

	{

	TBool* doesExist = iHierarchicalSupportTable.Find(aMediaType);

	if(doesExist)

	{

		return *doesExist;

	}

	TBool ret( EFalse );

	CNSmlDbCaps* dbCaps( NULL );

	TInt result = DbCapabilitiesL( dbCaps );

	User::LeaveIfError( result );

	CleanupStack::PushL( dbCaps );

	SmlDevInfDatastorePtr_t datastore = dbCaps->DatastoreL();

	CleanupStack::PushL( datastore );

	if ( datastore->rxpref->cttype->Data().Compare( aMediaType ) == 0 )

		{

		if ( datastore->supportHierarchicalSync )

			{

			ret = ETrue;

			}