/*

* 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:  Client Session for DS Host Servers

*

*/

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

// Includes

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

#include <s32mem.h>

#include <data_caging_path_literals.hrh>

#include <f32file.h>

#include <nsmlconstants.h>

#include <nsmlunicodeconverter.h>

#include "nsmldbcaps.h"

#include "nsmldshostclientsession.h"

#include "nsmldshostconstants.h"

#include "NSmldbcapsSerializer.h"

#include "nsmldsdpinformation.h"

#include "nsmldshostitem.h"

#include "nsmldsitemmodificationset.h"

#include "nsmlfilter.h"

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

// Constants

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

_LIT8( KNSmlFilterTypeEXCLUSIVE, "EXCLUSIVE" );

_LIT8( KNSmlFilterTypeINCLUSIVE, "INCLUSIVE" );

_LIT8( KNSmlFilterTypeCGI, "syncml::filtertype-cgi" );

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

// RNSmlDSHostClient - public methods

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

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

// RNSmlDSHostClient::Connect

// Connects client to Host Servers.

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

TInt RNSmlDSHostClient::Connect( const TDesC& aServerName, const TVersion& aVersion )

	{

	iMode = ENSmlNormalMode;

	TInt result( CreateSession( aServerName, aVersion ) );

	if ( result == KErrNotFound || result == KErrServerTerminated )

		{

		result = LaunchServer( aServerName );

		if ( result == KErrNone || result == KErrAlreadyExists )

			{

			result = CreateSession( aServerName, aVersion );

			}

		}

	return result;

	}

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

// RNSmlDSHostClient::Close

// Closes connection between client and Host Server.

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

void RNSmlDSHostClient::Close()

	{

	iChunk.Close();

	RSessionBase::Close();

	}

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

// RNSmlDSHostClient::CreateChunk

// Creates chunk that is used to transfer data between client and server.

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

TInt RNSmlDSHostClient::CreateChunk() const

	{

	return iChunk.CreateGlobal( KNullDesC, KNSmlDSHostChunkMinSize, KNSmlDSHostChunkMaxSize );

	}

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

// RNSmlDSHostClient::SendChunkHandle

// Sends Chunk handle to SyncML DS Host Servers.

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

TInt RNSmlDSHostClient::SendChunkHandle() const

	{

	TIpcArgs args;

 	args.Set(0, iChunk);

 	const TInt error = SendReceive( ENSmlHandleChunk, args );

 	return error;

	}

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

// RNSmlDSHostClient::CreateDataProvidersL

// Creates Data Providers.

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

void RNSmlDSHostClient::CreateDataProvidersL( const RArray<TSmlDataProviderId>& aIds, RArray<TInt>& aResultArray )

	{

	AdjustChunkIfNeededLC( sizeof( TInt32 ) * ( aIds.Count() + 1 ) );

	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( writeStream );

	writeStream.WriteInt32L( aIds.Count() );

	for ( TInt i = 0; i < aIds.Count(); i++ )

		{

		writeStream.WriteInt32L( aIds[i] );

		}

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(); // writeStream

	User::LeaveIfError( SendReceive( ENSmlDPOpen, TIpcArgs() ) );

	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( readStream );

	TInt count( readStream.ReadInt32L() );

	for ( TInt j = 0; j < count; j++ )

		{

		aResultArray.AppendL( readStream.ReadInt32L() );

		}

	CleanupStack::PopAndDestroy(2); // readStream, AdjustChunkIfNeededLC

	}

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

// RNSmlDSHostClient::CreateAllDataProvidersL

// Creates all possible Data Providers.

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

void RNSmlDSHostClient::CreateAllDataProvidersL( RArray<TSmlDataProviderId>& aIds, const RArray<TSmlDataProviderId>& aExceptIds )

	{

	AdjustChunkIfNeededLC( sizeof( TInt32 ) * ( aIds.Count() + 1 ) );

	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( writeStream );

	writeStream.WriteInt32L( aExceptIds.Count() );

	for ( TInt i = 0; i < aExceptIds.Count(); i++ )

		{

		writeStream.WriteInt32L( aExceptIds[ i ] );

		}

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(); // writeStream

	User::LeaveIfError( SendReceive( ENSmlDPOpenExcept, TIpcArgs() ) );

	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( readStream );

	TInt count( readStream.ReadInt32L() );

	for ( TInt j = 0; j < count; j++ )

		{

		aIds.AppendL( readStream.ReadInt32L() );

		}

	CleanupStack::PopAndDestroy(2); // readStream, AdjustChunkIfNeededLC

	}

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

// RNSmlDSHostClient::DataProviderInformationL

// 

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

TNSmlDPInformation* RNSmlDSHostClient::DataProviderInformationL( const TSmlDataProviderId aId, TInt& aResultCode ) const

	{

	TNSmlDPInformation* info = NULL;

	aResultCode = SendReceive( ENSmlDPInformation, TIpcArgs( aId ) );

	CleanupStack::PushL( TCleanupItem ( CancelAdjust, const_cast<RNSmlDSHostClient*>( this ) ) );

	if ( aResultCode == KErrNone )

		{

		CNSmlDPInformation* dpi = CNSmlDPInformation::NewLC();

		RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

		CleanupClosePushL( readStream );

		dpi->InternalizeL( readStream );

		CleanupStack::PopAndDestroy(); //readStream

		CleanupStack::Pop( dpi );

		info = dpi->InformationD();

		}

	CleanupStack::PopAndDestroy(); //CancelAdjust

	return info;

	}

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

// RNSmlDSHostClient::SupportsOperation

// Asks if Data Provider supports some operation.

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

TBool RNSmlDSHostClient::SupportsOperationL( TUid aOpId, const TSmlDataProviderId aId, TInt& aResultCode ) const

	{

	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( writeStream );

	writeStream.WriteInt32L( aOpId.iUid );

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(); // writeStream

	TPckgBuf<TInt> pckg;

	aResultCode = SendReceive( ENSmlDPSupportsOperation, TIpcArgs( aId, TIpcArgs::ENothing, &pckg ) );

	return pckg();

	}

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

// RNSmlDSHostClient::StoreFormatL

// Creates Data Store format of Data Provider.

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

CNSmlDbCaps* RNSmlDSHostClient::StoreFormatL( const TSmlDataProviderId aId, TInt& aResultCode )

	{

	TNSmlDbCapsSerializer ser;

	CNSmlDbCaps* dbcaps = NULL;

	aResultCode = SendReceive( ENSmlDPStoreFormat, TIpcArgs( aId ) );

	CleanupStack::PushL( TCleanupItem ( CancelAdjust, this ) );

	if ( aResultCode == KErrNone )

		{

		RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

		CleanupClosePushL( readStream );

		dbcaps = ser.InternalizeL( readStream );

		CleanupStack::PopAndDestroy(); // readStream

		}

	CleanupStack::PopAndDestroy(); //CancelAdjust

	return dbcaps;

	}

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

// RNSmlDSHostClient::ListStoresL

// Creates list of Data Store names of Data Provider.

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

void RNSmlDSHostClient::ListStoresL( CDesCArray* aNameList, const TSmlDataProviderId aId, TInt& aResultCode )

	{

	aNameList->Reset();

	aResultCode = SendReceive( ENSmlDPlListStores, TIpcArgs( aId ) );

	CleanupStack::PushL( TCleanupItem ( CancelAdjust, this ) );

	if ( aResultCode == KErrNone )

		{

		RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

		CleanupClosePushL( readStream );

		TInt32 i(0), storeCount( readStream.ReadInt32L() );

		for (; i < storeCount; i++ )

			{

			TInt32 length( readStream.ReadInt32L() );

			HBufC* store = HBufC::NewLC( readStream, length );

			aNameList->AppendL( *store );

			CleanupStack::PopAndDestroy( store );

			}

			CleanupStack::PopAndDestroy(); // readStream

		}

	CleanupStack::PopAndDestroy(); //CancelAdjust

	}

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

// RNSmlDSHostClient::DefaultStoreL

// Creates default name for Data Store of Data Provider.

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

HBufC* RNSmlDSHostClient::DefaultStoreL( const TSmlDataProviderId aId, TInt& aResultCode ) const

	{

	aResultCode = SendReceive( ENSmlDPDefaultStore, TIpcArgs( aId ) );

	if ( aResultCode )

		{

		return NULL;

		}

	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( readStream );

	TInt tempLength( readStream.ReadInt32L() );

	HBufC* tempName = HBufC::NewL( readStream, tempLength );

	CleanupStack::PopAndDestroy(); // readStream

	return tempName;

	}

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

// RNSmlDSHostClient::SupportedServerFiltersL

// This method returns the set of filters that can be used to send to the Sync Partner.

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

RPointerArray<CSyncMLFilter>* RNSmlDSHostClient::SupportedServerFiltersL( const TSmlDataProviderId aId, 

	TSyncMLFilterMatchType& aMatchType, TSyncMLFilterChangeInfo& aChangeInfo, TInt& aResultCode ) const

	{

	TPckgBuf<TSyncMLFilterMatchType> pckg;

	aResultCode = SendReceive( ENSmlServerFilters, TIpcArgs( aId, TIpcArgs::ENothing, &pckg ) );

	aMatchType = pckg();

	if ( aResultCode )

		{

		return NULL;

		}

	aChangeInfo = ESyncMLDefault;

	RPointerArray<CSyncMLFilter>* array = new ( ELeave ) RPointerArray<CSyncMLFilter>();

	CleanupRPtrArrayPushL( array );

	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( readStream );

	InternalizeFiltersL( readStream, *array );

	CleanupStack::PopAndDestroy(); // readStream

	CleanupStack::Pop(); //array

	return array;

	}

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

// RNSmlDSHostClient::CheckServerFiltersL

// This method updates dynamic filters up-to-date.

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

void RNSmlDSHostClient::CheckServerFiltersL( const TSmlDataProviderId aId, RPointerArray<CSyncMLFilter>& aFilters, TSyncMLFilterChangeInfo& aChangeInfo, TInt& aResultCode ) const

	{

	TStreamBuffers* sb = StreamBufferLC();	

	sb->iWrite->WriteInt32L( aChangeInfo );	

	ExternalizeFiltersL( *sb->iWrite, aFilters );

	sb->iWrite->CommitL();

	AdjustChunkIfNeededLC( sb->iBuffer->Size() );

	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( writeStream );

	writeStream.WriteL( *sb->iRead );

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(); // writeStream

	aResultCode = SendReceive( ENSmlUpdateServerFilters, TIpcArgs( aId ) );

	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( readStream );

	aChangeInfo = static_cast<TSyncMLFilterChangeInfo>( readStream.ReadInt32L() );

	InternalizeFiltersL( readStream, aFilters );

	CleanupStack::PopAndDestroy(3); // readStream, AdjustChunkIfNeededLC, sb

	}	

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

// RNSmlDSHostClient::CheckSupportedServerFiltersL

// This method checks what filters are supported by server

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

void RNSmlDSHostClient::CheckSupportedServerFiltersL( const TSmlDataProviderId aId, 

	const CNSmlDbCaps& aServerDataStoreFormat, const CArrayFix<TNSmlFilterCapData>& aFilterInfoArr, 

	RPointerArray<CSyncMLFilter>& aFilters, TSyncMLFilterChangeInfo& aChangeInfo, TInt& aResultCode ) const

	{

	TNSmlDbCapsSerializer ser;

	TStreamBuffers* sb = StreamBufferLC();	

	sb->iWrite->WriteInt32L( aChangeInfo );

	ser.ExternalizeL( aServerDataStoreFormat, aFilterInfoArr, *sb->iWrite );

	ExternalizeFiltersL( *sb->iWrite, aFilters );

	sb->iWrite->CommitL();

	AdjustChunkIfNeededLC( sb->iBuffer->Size() );

	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( writeStream );

	writeStream.WriteL( *sb->iRead );

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(); // writeStream

	aResultCode = SendReceive( ENSmlCheckSupportedServerFilters, TIpcArgs( aId ) );

	if ( aResultCode == KErrNone )

		{

		RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

		CleanupClosePushL( readStream );

		aChangeInfo = static_cast<TSyncMLFilterChangeInfo>( readStream.ReadInt32L() );

		InternalizeFiltersL( readStream, aFilters );

		CleanupStack::PopAndDestroy(); //readStream

		}

	CleanupStack::PopAndDestroy(2); //AdjustChunkIfNeededLC, sb

	}

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

// CNSmlDSHostClient::GetFilterL

// Get Filters.

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

void RNSmlDSHostClient::GetFilterL( const TSmlDataProviderId aId, const TDesC& aStoreName, const RPointerArray<CSyncMLFilter>& aFilterArray, CNSmlFilter*& aFilter, TSyncMLFilterMatchType aMatchType, TInt& aResultCode )

	{

	TStreamBuffers* sb = StreamBufferLC();

	sb->iWrite->WriteInt32L( aMatchType );

	ExternalizeFiltersL( *sb->iWrite, aFilterArray );

	sb->iWrite->CommitL();

	AdjustChunkIfNeededLC( sb->iBuffer->Size() );

	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( writeStream );

	writeStream.WriteL( *sb->iRead );

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(); // writeStream

	aResultCode = SendReceive( ENSmlFilters, TIpcArgs( aId, &aStoreName ) );

	if ( aResultCode == KErrNone )

		{

		GetFilterFromChunkL( aFilter );

		}

	CleanupStack::PopAndDestroy(2); //AdjustChunkIfNeededLC, sb 

	}

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

// CNSmlDSHostClient::GetFilterFromChunkL

// creates filter from chunk

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

void RNSmlDSHostClient::GetFilterFromChunkL( CNSmlFilter*& aFilter )

	{

	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( readStream );

	TSyncMLFilterType filterType( static_cast<TSyncMLFilterType>( readStream.ReadInt32L() ) ); 

	HBufC* query = HBufC::NewLC( readStream, readStream.ReadUint32L() );

	HBufC* recordMimeType = HBufC::NewLC( readStream, readStream.ReadUint32L() );

	HBufC* fieldMimeType = HBufC::NewLC( readStream, readStream.ReadUint32L() );

	RStringPool pool;

	pool.OpenL();

	CleanupClosePushL( pool );			

	//properties

	RPointerArray<CSmlDataProperty> properties;

    CleanupStack::PushL( PtrArrCleanupItemRArr( 

			CSmlDataProperty, &properties ) );

	TInt count( readStream.ReadUint32L() );

	for ( TInt i = 0; i < count; i++ )

		{

		CSmlDataProperty* prop = CSmlDataProperty::NewLC( pool, readStream );

		properties.AppendL( prop );

		CleanupStack::Pop( prop );

		}

	aFilter = CNSmlFilter::NewLC();

	if ( filterType == ESyncMLTypeInclusive )

		{

		aFilter->SetFilterTypeL( KNSmlFilterTypeINCLUSIVE );

		}

	else if ( filterType == ESyncMLTypeExclusive )

		{

		aFilter->SetFilterTypeL( KNSmlFilterTypeEXCLUSIVE );

		}

	HBufC8* tmpbuf = NULL;

	NSmlUnicodeConverter::HBufC8InUTF8LC( *recordMimeType, tmpbuf );

	aFilter->SetFilterMetaTypeL( *tmpbuf );

	CleanupStack::PopAndDestroy();

	NSmlUnicodeConverter::HBufC8InUTF8LC( *fieldMimeType, tmpbuf );

	aFilter->SetFieldMetaTypeL( *tmpbuf );

	CleanupStack::PopAndDestroy();

	NSmlUnicodeConverter::HBufC8InUTF8LC( *query, tmpbuf );

	aFilter->SetRecordL( KNSmlFilterTypeCGI, *tmpbuf );

	CleanupStack::PopAndDestroy();

	AddFilterPropertiesL( properties, *aFilter );

	CleanupStack::Pop(); // aFilter

	CleanupStack::PopAndDestroy(6); // pool, properties, fieldMimeType, recordMimeType, query, readStream

	}

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

// RNSmlDSHostClient::AddFilterPropertiesL

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

void RNSmlDSHostClient::AddFilterPropertiesL( const RPointerArray<CSmlDataProperty>& properties, CNSmlFilter& aFilter ) const

	{

	TNSmlDbCapsSerializer ser;

	for ( TInt i = 0; i < properties.Count(); i++ )

		{

		const CSmlDataProperty* prop = properties[i];

		CNSmlDevInfProp* dip = aFilter.AddFieldDataPropLC( prop->Field().Name().DesC() );

		ser.SetFromL( *prop, *dip );

		CleanupStack::Pop(); // dip

		}

	}

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

// RNSmlDSHostClient::OpenL

// Opens the data store specified by aStoreName asynchronously.

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

void RNSmlDSHostClient::OpenL( const TSmlDataProviderId aId, const TDesC& aStoreName, const TDesC& aServerId, const TDesC& aRemoteDB, TInt& aResultCode ) const

	{

	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

	CleanupClosePushL( writeStream );

	writeStream.WriteUint32L( aServerId.Length() );

	writeStream << aServerId;

	writeStream.WriteUint32L( aRemoteDB.Length() );

	writeStream << aRemoteDB;

	CleanupStack::PopAndDestroy(); // writeStream

	aResultCode = SendReceive( ENSmlDSOpen, TIpcArgs( aId, &aStoreName ) );

	}

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

// RNSmlDSHostClient::CancelRequest

// Cancel the current asynchronous request.

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

void RNSmlDSHostClient::CancelRequest( const TSmlDataProviderId aId, const TDesC& aStoreName, TInt& aResultCode ) const

	{

	aResultCode = SendReceive( ENSmlDSCancelRequest, TIpcArgs( aId, &aStoreName ) );

	}

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

// RNSmlDSHostClient::BeginTransaction

// Starts the transaction mode.

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

void RNSmlDSHostClient::BeginTransaction( const TSmlDataProviderId aId, const TDesC& aStoreName, TInt& aResultCode )

	{

	iMode = ENSmlTransactionMode;

	aResultCode = SendReceive( ENSmlDSBeginTransaction, TIpcArgs( aId, &aStoreName ) );

	}

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

// RNSmlDSHostClient::CommitTransaction

// Method will be called at the end of a successful transaction.

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

void RNSmlDSHostClient::CommitTransaction( const TSmlDataProviderId aId, const TDesC& aStoreName, TInt& aResultCode )

	{

	iMode = ENSmlNormalMode;

	aResultCode = SendReceive( ENSmlDSCommitTransaction, TIpcArgs( aId, &aStoreName ) );

	}