/*

* 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:  Session for DS host server.

*

*/

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

// Includes

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

#include <s32mem.h>

#include <implementationinformation.h>

#include <ecom.h>

#include <badesca.h>

#include <nsmldebug.h>

#include <SmlDataFormat.h>

#include "NSmlAdapterLog.h"

#include "nsmldshostconstants.h"

#include "Nsmldshostserver.h"

#include "Nsmldshostsession.h"

#include "nsmldsdpinformation.h"

#include "Nsmldsdataproviderarray.h"

#ifdef __HOST_SERVER_MTEST__

#include "../../stif/DSHostServerTest/src/fakedataprovider.cpp"

#else

#include <nsmlchangefinder.h>	//for CNSmlDataItemUidSet

#endif

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

// CNSmlDSHostSession::TMemPtr::WriteStreamLC

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

RWriteStream& CNSmlDSHostSession::TMemPtr::WriteStreamLC() const

    {

    RMemWriteStream* writeStream = new ( ELeave ) RMemWriteStream( Ptr(), Size() );

    CleanupStack::PushL( TCleanupItem ( CleanupWriteStream, writeStream ) );

    return *writeStream;

    }

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

// CNSmlDSHostSession::TMemPtr::StreamBufferLC

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

CNSmlDSHostSession::TMemPtr::TStreamBuffers* 

	CNSmlDSHostSession::TMemPtr::StreamBufferLC() const

	{

	TStreamBuffers* cleanup = new ( ELeave ) TStreamBuffers;

	CleanupStack::PushL( TCleanupItem ( CleanupStreamBuffer, cleanup ) );

	cleanup->iBuffer = CBufFlat::NewL( 64 );

	cleanup->iWrite = new ( ELeave ) RBufWriteStream( *cleanup->iBuffer );

	cleanup->iRead = new ( ELeave ) RBufReadStream( *cleanup->iBuffer );

	return cleanup;

	}

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

// CNSmlDSHostSession::TMemPtr::ReadStreamLC

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

RReadStream& CNSmlDSHostSession::TMemPtr::ReadStreamLC() const

    {

    RMemReadStream* readStream = new ( ELeave ) RMemReadStream( Ptr(), iChunk.Size() );

    CleanupStack::PushL( TCleanupItem ( CleanupReadStream, readStream ) );

    return *readStream;

    }

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

// CNSmlDSHostSession::TMemPtr::AdjustChunkIfNeededL

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

void CNSmlDSHostSession::TMemPtr::AdjustChunkIfNeededL( TInt iNeededSize )

	{

	if ( Size() < iNeededSize )

		{

		User::LeaveIfError( Adjust(iNeededSize) );

		}

	}

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

// CNSmlDSHostSession::TMemPtr::CleanupWriteStream

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

void CNSmlDSHostSession::TMemPtr::CleanupWriteStream( TAny* aP )

	{

	RMemWriteStream* writeStream = reinterpret_cast<RMemWriteStream*>( aP );

	writeStream->Close();

	delete writeStream;

	}

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

// CNSmlDSHostSession::TMemPtr::CleanupReadStream

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

void CNSmlDSHostSession::TMemPtr::CleanupReadStream( TAny* aP )

	{

	RMemReadStream* readStream = reinterpret_cast<RMemReadStream*>( aP );

	readStream->Close();

	delete readStream;

	}

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

// CNSmlDSHostSession::TMemPtr::CleanupStreamBuffer

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

void CNSmlDSHostSession::TMemPtr::CleanupStreamBuffer( TAny* aP )

	{

	TStreamBuffers* cleanup = reinterpret_cast<TStreamBuffers*>( aP );

	if ( cleanup->iWrite )

		{

		cleanup->iWrite->Close();

		delete cleanup->iWrite;

		}

	if ( cleanup->iRead )

		{

		cleanup->iRead->Close();

		delete cleanup->iRead;

		}

	delete cleanup->iBuffer;

	delete cleanup;

	}

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

// CNSmlDSHostSession::TMemPtr::CancelAdjust

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

void CNSmlDSHostSession::TMemPtr::CancelAdjust( TAny* aP )

	{

	if ( aP )

		{

		TMemPtr* memptr = reinterpret_cast<TMemPtr*>( aP );

		memptr->Adjust( KNSmlDSHostChunkMinSize );

		}

	}

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

// CNSmlDSHostSession::CNSmlServerDSHostItem::NewLC

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

CNSmlDSHostSession::CNSmlServerDSHostItem* CNSmlDSHostSession::CNSmlServerDSHostItem::NewLC()

	{

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

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

// CNSmlDSHostSession::NewL

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

CNSmlDSHostSession* CNSmlDSHostSession::NewL( CNSmlDSHostServer& aServer )

	{

	_DBG_FILE( "CNSmlDSHostSession::NewL(): begin" );

	CNSmlDSHostSession* self= new ( ELeave ) CNSmlDSHostSession( aServer );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	_DBG_FILE( "CNSmlDSHostSession::NewL(): end" );

	return self;

	}

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

// CNSmlDSHostSession::~CNSmlDSHostSession

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

CNSmlDSHostSession::~CNSmlDSHostSession()

	{

	_DBG_FILE( "CNSmlDSHostSession::~CNSmlDSHostSession(): begin" );

    iMemPtr.iChunk.Close();

    iDataProviders.ResetAndDestroy();

    iStringPool.Close();

    REComSession::FinalClose();

    iServer.DecSessionCount();

	_DBG_FILE( "CNSmlDSHostSession::~CNSmlDSHostSession(): end" );

	}

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

// CNSmlDSHostSession::ServiceL

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

void CNSmlDSHostSession::ServiceL( const RMessage2& aMessage )

	{

	_DBG_FILE( "CNSmlDSHostSession::ServiceL(): begin" );

    TBool completeRequest( ETrue );

	TRAPD( err, DispatchMessageL( aMessage, completeRequest ) );

    if ( completeRequest && !aMessage.IsNull() )

        {

        aMessage.Complete( err );

        }

	DBG_FILE_CODE( err, _S8( "CNSmlDSHostSession::ServiceL() returned" ) );

	}

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

// CNSmlDSHostSession::DispatchMessageL

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

void CNSmlDSHostSession::DispatchMessageL( const RMessage2& aMessage, TBool& aCompleteRequest )

	{

	_DBG_FILE( "CNSmlDSHostSession::DispatchMessageL(): begin" );

    aCompleteRequest = ETrue;

	switch( aMessage.Function() )

        {

	    case ENSmlDPOpen:

	    	_DBG_FILE("CreateDataProvidersL"); 

	        CreateDataProvidersL( aMessage );

	        break;

	    case ENSmlDPOpenExcept:

	        _DBG_FILE("CreateDataProvidersExceptL"); 

	        CreateDataProvidersExceptL( aMessage );

	        break;

	    case ENSmlDPInformation:

	    	_DBG_FILE("DPInformation"); 

	    	DPInformationL( aMessage );

	    	break;

		case ENSmlHandleChunk:

			_DBG_FILE("HandleChunk"); 

			HandleChunk( aMessage );

	        break;

		case ENSmlDPSupportsOperation:

			_DBG_FILE("SupportsOperationL"); 

	        SupportsOperationL( aMessage );

	        break;

		case ENSmlDPStoreFormat:

			_DBG_FILE("StoreFormatL"); 

	        StoreFormatL( aMessage );

	        break;

		case ENSmlDPlListStores:

	        _DBG_FILE("ListStoresL"); 

	        ListStoresL( aMessage );

	        break;

		case ENSmlDPDefaultStore:

	        _DBG_FILE("DefaultStoreL"); 

	        DefaultStoreL( aMessage );

	        break;

	    case ENSmlServerFilters:

	    	_DBG_FILE("SupportedServerFiltersL"); 

	        SupportedServerFiltersL( aMessage );

	        break;

        case ENSmlUpdateServerFilters:

        	_DBG_FILE("CheckServerFiltersL");

        	CheckServerFiltersL( aMessage );

        	break;

        case ENSmlCheckSupportedServerFilters:

        	_DBG_FILE("CheckSupportedServerFiltersL");

        	CheckSupportedServerFiltersL( aMessage );

        	break;

        case ENSmlFilters:

        	_DBG_FILE("GetFiltersL");

        	GetFiltersL( aMessage );

        	break;

		case ENSmlDSOpen:

	        _DBG_FILE("OpenL"); 

	        OpenL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlDSCancelRequest:

	        _DBG_FILE("CancelRequestL"); 

	        CancelRequestL( aMessage );

	        break;

		case ENSmlDSBeginTransaction:

	        _DBG_FILE("BeginTransactionL"); 

	        BeginTransactionL( aMessage );

	        break;

		case ENSmlDSCommitTransaction:

	        _DBG_FILE("CommitTransactionL"); 

	        CommitTransactionL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlDSRevertTransaction:

	        _DBG_FILE("RevertTransactionL"); 

	        RevertTransactionL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlDSBeginBatch:

	        _DBG_FILE("BeginBatchL"); 

	        BeginBatchL( aMessage );

	        break;

		case ENSmlDSCommitBatch:

	        _DBG_FILE("CommitBatchL"); 

	        CommitBatchL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlDSCancelBatch:

	        _DBG_FILE("CancelBatchL"); 

	        CancelBatchL( aMessage );

	        break;

		case ENSmlDSSetDataStoreFormat:

	        _DBG_FILE("SetRemoteDataStoreFormatL"); 

	        SetRemoteDataStoreFormatL( aMessage );

	        break;

		case ENSmlDSRemoteMaxObjSize:

	        _DBG_FILE("SetRemoteMaxObjectSizeL"); 

	        SetRemoteMaxObjectSizeL( aMessage );

	        break;

		case ENSmlMaxObjSize:

	        _DBG_FILE("MaxObjectSizeL"); 

	        MaxObjectSizeL( aMessage );

	        break;

		case ENSmlItemOpen:

	        _DBG_FILE("OpenItemL"); 

	        OpenItemL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlItemCreate:

	        _DBG_FILE("CreateItemL"); 

	        CreateItemL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlItemReplace:

	        _DBG_FILE("ReplaceItemL"); 

	        ReplaceItemL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlItemRead:

	        _DBG_FILE("ReadItemL"); 

	        ReadItemL( aMessage );

	        break;

		case ENSmlItemWrite:

	        _DBG_FILE("WriteItemL"); 

	        WriteItemL( aMessage );

	        break;

		case ENSmlItemCommit:

	        _DBG_FILE("CommitItemL"); 

	        CommitItemL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlItemClose:

	        _DBG_FILE("CloseItemL"); 

	        CloseItemL( aMessage );

	        break;

		case ENSmlItemMove:

	        _DBG_FILE("MoveItemL"); 

	        MoveItemL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlItemDelete:

	        _DBG_FILE("DeleteItemL"); 

	        DeleteItemL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlItemSoftDelete:

	        _DBG_FILE("SoftDeleteItemL"); 

	        SoftDeleteItemL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlItemDeleteAll:

	        _DBG_FILE("DeleteAllItemsL"); 

	        DeleteAllItemsL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlDSSyncHistory:

	        _DBG_FILE("HasSyncHistoryL"); 

	        HasSyncHistoryL( aMessage );

	        break;

		case ENSmlDSItemsAdded:

	        _DBG_FILE("AddedItemsL"); 

	        AddedItemsL( aMessage );

	        break;

		case ENSmlDSItemsDeleted:

	        _DBG_FILE("DeletedItemsL"); 

	        DeletedItemsL( aMessage );

	        break;

		case ENSmlDSItemsSofDeleted:

	        _DBG_FILE("SoftDeleteItemsL"); 

	        SoftDeleteItemsL( aMessage );

	        break;

		case ENSmlDSItemsModified:

	        _DBG_FILE("ModifiedItemsL"); 

	        ModifiedItemsL( aMessage );

	        break;

		case ENSmlDSItemsMoved:

	        _DBG_FILE("MovedItemsL"); 

	        MovedItemsL( aMessage );

	        break;

	    case ENSmlDSItemsAll:

	    	_DBG_FILE("AllItems"); 

	    	AllItemsL( aMessage ); aCompleteRequest = EFalse;

	    	break;

		case ENSmlDSResetChangeInfo:

	        _DBG_FILE("ResetChangeInfoL"); 

	        ResetChangeInfoL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlDSCommitChanges:

	        _DBG_FILE("CommitChangesL"); 

	        CommitChangesL( aMessage ); aCompleteRequest = EFalse;

	        break;

		case ENSmlDSCommitAllChanges:

	        _DBG_FILE("CommitAllChangesL"); 

	        CommitAllChangesL( aMessage ); aCompleteRequest = EFalse;

	        break;

        case ENSmlDSUpdateServerId:

        	_DBG_FILE("Update server id"); 

        	UpdateServerIdL( aMessage );

        	break;

		default:

			_DBG_FILE("Unknown function"); 

			PanicClient( aMessage, KErrNotSupported );

        }

	_DBG_FILE( "CNSmlDSHostSession::DispatchMessageL(): end" );

	}

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

// CNSmlDSHostSession::CNSmlDSHostSession

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

CNSmlDSHostSession::CNSmlDSHostSession( CNSmlDSHostServer& aServer ) : 

    iServer( aServer )

	{

	_DBG_FILE( "CNSmlDSHostSession::CNSmlDSHostSession(): begin" );

	iServer.IncSessionCount();

	_DBG_FILE( "CNSmlDSHostSession::CNSmlDSHostSession(): end" );

	}

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

// CNSmlDSHostSession::ConstructL

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

void CNSmlDSHostSession::ConstructL()

	{

	_DBG_FILE( "CNSmlDSHostSession::ConstructL(): begin" );

    iStringPool.OpenL();

	_DBG_FILE( "CNSmlDSHostSession::ConstructL(): end" );

	}

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

// CNSmlDSHostSession::HandleChunk

// 

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

void CNSmlDSHostSession::HandleChunk( const RMessage2& aMessage )

	{

	iMemPtr.iChunk.Close();

	const TInt error = iMemPtr.iChunk.Open(aMessage, 0, EFalse);

	}

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

// CNSmlDSHostSession::CreateDataProvidersL

// Creates Data Providers.

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

void CNSmlDSHostSession::CreateDataProvidersL( const RMessage2& /*aMessage*/ )

	{

	RArray<TInt> results;

    CleanupClosePushL( results );

    TMemPtr& ptr( MemPtrL() );

    RReadStream& readStream = ptr.ReadStreamLC();

    const TUint uidCount ( readStream.ReadInt32L() ) ;

    for( TUint i = 0; i < uidCount; i++ )

        {

        TSmlDataProviderId id;

        TPckg<TSmlDataProviderId> dpid( id );

        readStream.ReadL( dpid );

        TRAPD( err, CreateDataProviderL( dpid() ) );

        results.AppendL( err );

        }

    CleanupStack::PopAndDestroy(); //readStream

    //to chunk

    ptr.AdjustChunkIfNeededL( sizeof( TInt32 ) * ( results.Count() + 1 ) );

    RWriteStream& writeStream = ptr.WriteStreamLC();

    writeStream.WriteInt32L( results.Count() );

    for( TInt j = 0; j < results.Count(); j++ )

        {

        writeStream.WriteInt32L( results[j] );

        }

    writeStream.CommitL();

    CleanupStack::PopAndDestroy(2); //writeStream, results

	}

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

// CNSmlDSHostSession::CreateDataProvidersExceptL

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

void CNSmlDSHostSession::CreateDataProvidersExceptL( const RMessage2& /*aMessage*/ )

    {

    iDataProviders.ResetAndDestroy();

    RArray<TSmlDataProviderId> results;

    CleanupClosePushL( results );

    TMemPtr& ptr( MemPtrL() );

    RReadStream& readStream = ptr.ReadStreamLC();

    //copying except uids to array.

    const TInt exceptIdCount ( readStream.ReadInt32L() );

    RArray<TSmlDataProviderId> exceptIds( Max<TInt>( 2, exceptIdCount ) );

    CleanupClosePushL( exceptIds );

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

    	{

    	TSmlDataProviderId id;

    	TPckg<TSmlDataProviderId> dpid( id );

        readStream.ReadL( dpid );

        exceptIds.AppendL( dpid() );

    	}

	TUid DsUid = { KNSmlDSInterfaceUid };

	RImplInfoPtrArray implArray;

    CleanupStack::PushL( PtrArrCleanupItemRArr( 

			CImplementationInformation, &implArray ) );

	REComSession::ListImplementationsL( DsUid, implArray );

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

        {

        CImplementationInformation* implInfo = implArray[i];

        TSmlDataProviderId uid = implInfo->ImplementationUid().iUid;

        if ( exceptIds.Find( uid ) == KErrNotFound )

            {

            TRAPD( err, CreateDataProviderL( uid ) );

            if ( err == KErrNone )

                {

                results.AppendL( uid );

                }

            }

        }

    CleanupStack::PopAndDestroy(3); //implArray, exceptIds, readStream

    //to chunk

    TStreamBuffers* sb = ptr.StreamBufferLC();

    sb->iWrite->WriteInt32L( results.Count() );

    for( TInt j = 0; j < results.Count(); j++ )

        {

        TPckgC<TSmlDataProviderId> dpid( results[j] );

        sb->iWrite->WriteL( dpid );

        }

    StreamBufferToChunkL( ptr, sb );

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

    }

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