diff -r 000000000000 -r b497e44ab2fc syncmlfw/ds/hostserver/dshostserverbase/src/Nsmldshostsession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/syncmlfw/ds/hostserver/dshostserverbase/src/Nsmldshostsession.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,1894 @@ +/* +* 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 +#include +#include +#include +#include +#include + +#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 //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( aP ); + writeStream->Close(); + delete writeStream; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::TMemPtr::CleanupReadStream +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::TMemPtr::CleanupReadStream( TAny* aP ) + { + RMemReadStream* readStream = reinterpret_cast( aP ); + readStream->Close(); + delete readStream; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::TMemPtr::CleanupStreamBuffer +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::TMemPtr::CleanupStreamBuffer( TAny* aP ) + { + TStreamBuffers* cleanup = reinterpret_cast( 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( 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 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 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 results; + CleanupClosePushL( results ); + + TMemPtr& ptr( MemPtrL() ); + RReadStream& readStream = ptr.ReadStreamLC(); + + //copying except uids to array. + const TInt exceptIdCount ( readStream.ReadInt32L() ); + + RArray exceptIds( Max( 2, exceptIdCount ) ); + CleanupClosePushL( exceptIds ); + + for ( TInt i = 0; i < exceptIdCount; i++ ) + { + TSmlDataProviderId id; + TPckg 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 dpid( results[j] ); + sb->iWrite->WriteL( dpid ); + } + StreamBufferToChunkL( ptr, sb ); + + CleanupStack::PopAndDestroy(2); //sb, results + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CreateDataProviderL +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CreateDataProviderL( TSmlDataProviderId aId ) + { + CSmlDataProvider* dp = CSmlDataProvider::NewL( aId ); + CleanupStack::PushL( dp ); + TInt ret = iDataProviders.InsertL( dp ); + if ( ret == KErrNone ) + { + CleanupStack::Pop( dp ); + } + else + { + CleanupStack::PopAndDestroy( dp ); + } + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DPInformationL +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::DPInformationL( const RMessage2& aMessage ) + { + TSmlDataProviderId id( aMessage.Int0() ); + CSmlDataProvider* dp = DataProviderL( id ); + CNSmlDPInformation* dpi = CNSmlDPInformation::NewLC(); + TMemPtr& ptr( MemPtrL() ); + + const CSmlDataStoreFormat& storeFormat = dp->StoreFormatL(); + dpi->SetId( id ); + + CDesC8Array* mimetypes = new ( ELeave ) CDesC8ArrayFlat( storeFormat.MimeFormatCount() ); + CleanupStack::PushL( mimetypes ); + CDesC8Array* mimevers = new ( ELeave ) CDesC8ArrayFlat( storeFormat.MimeFormatCount() ); + CleanupStack::PushL( mimevers ); + + for ( TInt i = 0; i < storeFormat.MimeFormatCount(); i++ ) + { + const CSmlMimeFormat& mf = storeFormat.MimeFormat(i); + mimetypes->AppendL( mf.MimeType().DesC() ); + mimevers->AppendL( mf.MimeVersion().DesC() ); + } + + dpi->SetMimeTypesL( mimetypes ); + dpi->SetMimeVersL( mimevers ); + + CleanupStack::Pop( 2 ); //mimetypes, mimevers + + if ( storeFormat.IsSupported( CSmlDataStoreFormat::EOptionHierarchial ) ) + { + dpi->SetProtocolVersion( ESmlVersion1_2 ); + } + else + { + dpi->SetProtocolVersion( ESmlVersion1_1_2 ); + } + + 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]; + if ( id == implInfo->ImplementationUid().iUid ) + { + TVersion version( implInfo->Version(), 0, 0 ); + dpi->SetVersion( version ); + dpi->SetDisplayNameL( implInfo->DisplayName() ); + } + } + + CleanupStack::PopAndDestroy(); //implArray + TStreamBuffers* sb = ptr.StreamBufferLC(); + dpi->ExternalizeL( *sb->iWrite ); + StreamBufferToChunkL( ptr, sb ); + CleanupStack::PopAndDestroy( 2 ); //sb, dpi + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::SupportsOperationL +// Asks if Data Provider supports some operation. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::SupportsOperationL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + TMemPtr& ptr( MemPtrL() ); + TInt32 tmp(0); + TPckg uidpck( tmp ); + ptr.CopyTo( uidpck ); + TUid uid( TUid::Uid( uidpck() ) ); + TBool retVal( dp->SupportsOperation( uid ) ); + TPckgC respck( retVal ); + aMessage.WriteL( 2, respck ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::StoreFormatL +// Creates Data Store format of Data Provider. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::StoreFormatL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + TMemPtr& destPtr( MemPtrL() ); + + TStreamBuffers* sb = destPtr.StreamBufferLC(); + const CSmlDataStoreFormat& dsf = dp->StoreFormatL(); + dsf.ExternalizeL( *sb->iWrite ); + StreamBufferToChunkL( destPtr, sb ); + + CleanupStack::PopAndDestroy(); //sb + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::ListStoresL +// Creates list of Data Store names of Data Provider. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::ListStoresL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + CDesCArray* stores = dp->ListStoresLC(); + + TMemPtr& destPtr( MemPtrL() ); + TInt size( sizeof( TInt32 ) ); + + if ( stores ) + { + for ( TInt i = 0; i < stores->Count(); i++ ) + { + size += ( *stores )[i].Size() + sizeof( TInt32 ); + } + } + + destPtr.AdjustChunkIfNeededL( size ); + RWriteStream& wStream = destPtr.WriteStreamLC(); + + if ( stores ) + { + wStream.WriteInt32L( stores->Count() ); + for ( TInt i = 0; i < stores->Count(); i++ ) + { + wStream.WriteInt32L( ( *stores )[i].Length() ); + wStream << ( *stores )[i]; + } + } + else + { + wStream.WriteInt32L( 0 ); + } + + wStream.CommitL(); + CleanupStack::PopAndDestroy(2); //wStream, stores + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DefaultStoreL +// Creates default name for Data Store of Data Provider. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::DefaultStoreL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + const TDesC& defStore = dp->DefaultStoreL(); + TMemPtr& dest( MemPtrL() ); + dest.AdjustChunkIfNeededL( defStore.Size() + sizeof( TInt32 ) + 2 ); + RWriteStream& wStream = dest.WriteStreamLC(); + wStream.WriteInt32L( defStore.Length() ); + wStream << defStore; + wStream.CommitL(); + CleanupStack::PopAndDestroy(); //wStream + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::SupportedServerFiltersL +// This method returns the set of filters that can be used to send to the Sync Partner. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::SupportedServerFiltersL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + + TBool suppOp( dp->SupportsOperation( KUidSmlSupportsUserSelectableMatchType ) ); + TSyncMLFilterMatchType matchType( ESyncMLMatchDisabled ); + if ( suppOp ) + { + matchType = ESyncMLMatchNotSelected; + } + + TPckgC matchTypePckg( matchType ); + aMessage.WriteL( 2, matchTypePckg ); + + const RPointerArray& filters = dp->SupportedServerFiltersL(); + + TMemPtr& dest( MemPtrL() ); + TStreamBuffers* sb = dest.StreamBufferLC(); + ExternalizeFiltersL( *sb->iWrite, filters ); + StreamBufferToChunkL( dest, sb ); + + CleanupStack::PopAndDestroy(); //sb + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CheckServerFiltersL +// This method updates dynamic filters up-to-date +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CheckServerFiltersL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + + RPointerArray *filters = new ( ELeave ) RPointerArray(); + CleanupRPtrArrayPushL( filters ); + + TMemPtr& memptr( MemPtrL() ); + RReadStream& rStream = memptr.ReadStreamLC(); + TSyncMLFilterChangeInfo changeInfo( static_cast( rStream.ReadInt32L() ) ); + + InternalizeFiltersL( rStream, *filters ); + CleanupStack::PopAndDestroy(); //rStream + + dp->CheckServerFiltersL( *filters, changeInfo ); + + TStreamBuffers* sb = memptr.StreamBufferLC(); + sb->iWrite->WriteInt32L( changeInfo ); + ExternalizeFiltersL( *sb->iWrite, *filters ); + StreamBufferToChunkL( memptr, sb ); + + CleanupStack::PopAndDestroy(2); //sb, filters + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CheckSupportedServerFiltersL +// Calls CSmlDataProvider::CheckSupportedServerFiltersL. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CheckSupportedServerFiltersL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + + RPointerArray *filters = new ( ELeave ) RPointerArray(); + CleanupRPtrArrayPushL( filters ); + + TMemPtr& memptr( MemPtrL() ); + RReadStream& rStream = memptr.ReadStreamLC(); + TSyncMLFilterChangeInfo changeInfo( static_cast( rStream.ReadInt32L() ) ); + CSmlDataStoreFormat* dataStoreFormat = CSmlDataStoreFormat::NewLC( iStringPool, rStream ); + InternalizeFiltersL( rStream, *filters ); + + dp->CheckSupportedServerFiltersL(*dataStoreFormat, *filters, changeInfo ); + CleanupStack::PopAndDestroy(2); //rStream, dataStoreFormat + + TStreamBuffers* sb = memptr.StreamBufferLC(); + sb->iWrite->WriteInt32L( changeInfo ); + ExternalizeFiltersL( *sb->iWrite, *filters ); + StreamBufferToChunkL( memptr, sb ); + + CleanupStack::PopAndDestroy(2); //sb, filters + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::GetFiltersL +// This method updates dynamic filters up-to-date +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::GetFiltersL( const RMessage2& aMessage ) + { + CSmlDataProvider* dp = DataProviderL( aMessage.Int0() ); + + HBufC* storename = DataStoreNameLC( aMessage ); + + RPointerArray* filters = new ( ELeave ) RPointerArray(); + CleanupRPtrArrayPushL( filters ); + + TMemPtr& memptr( MemPtrL() ); + RReadStream& rStream ( memptr.ReadStreamLC() ); + TSyncMLFilterMatchType matchType ( static_cast( rStream.ReadInt32L() ) ); + InternalizeFiltersL( rStream, *filters ); + + TBuf<64> recordMimeType; + + TSyncMLFilterType filterType( ESyncMLTypeInclusive ); + HBufC* query = dp->GenerateRecordFilterQueryLC( *filters, matchType, recordMimeType, filterType, *storename ); + + RPointerArray properties; + CleanupStack::PushL( PtrArrCleanupItemRArr( + CSmlDataProperty, &properties ) ); + + TBuf<64> fieldMimeType; + + dp->GenerateFieldFilterQueryL( *filters, fieldMimeType, properties, *storename ); + + TStreamBuffers* sb = memptr.StreamBufferLC(); + sb->iWrite->WriteInt32L( filterType ); + if ( query ) + { + sb->iWrite->WriteInt32L( query->Length() ); + (*sb->iWrite) << *query; + } + else + { + sb->iWrite->WriteInt32L( 0 ); + (*sb->iWrite) << KNullDesC; + } + + sb->iWrite->WriteInt32L( recordMimeType.Length() ); + (*sb->iWrite) << recordMimeType; + sb->iWrite->WriteInt32L( fieldMimeType.Length() ); + (*sb->iWrite) << fieldMimeType; + + sb->iWrite->WriteInt32L( properties.Count() ); + for ( TInt i = 0; i < properties.Count(); i++ ) + { + properties[i]->ExternalizeL( *sb->iWrite ); + } + + StreamBufferToChunkL( memptr, sb ); + + CleanupStack::PopAndDestroy(6); //sb, properties, query, rStream, filters, storename + + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::OpenL +// Opens the data store specified by aStoreName. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::OpenL( const RMessage2& aMessage ) + { + if ( HasDataStoreL( aMessage ) ) + { + User::Leave( KErrAlreadyExists ); + } + + CNSmlDSAsyncCallBackForOpen* p = new ( ELeave ) CNSmlDSAsyncCallBackForOpen( + this, aMessage, OpenFinishedL ); + CleanupStack::PushL( p ); + + p->iDpi = DataProviderItemL( aMessage.Int0() ); + CSmlDataProvider* dp = p->iDpi->iDataprovider; + TMemPtr& memptr( MemPtrL() ); + RReadStream& rStream = memptr.ReadStreamLC(); + + //server id + TInt tempLength = rStream.ReadUint32L(); + p->iServerId = HBufC::NewL( rStream, tempLength ); + + //remotedb + tempLength = rStream.ReadUint32L(); + p->iRemoteDB = HBufC::NewL( rStream, tempLength ); + + CleanupStack::PopAndDestroy(); //rStream + + //Localdb same as storename + HBufC* storeName = DataStoreNameLC( aMessage ); + + CNSmlAdapterLog* adpLog = CNSmlAdapterLog::NewL(); + CleanupStack::PushL( adpLog ); + + adpLog->SetAdapterLogKeyL( dp->Identifier(), *storeName, *p->iServerId, *p->iRemoteDB ); + CSmlDataStore* ds = dp->NewStoreInstanceLC(); + p->iDSItem = iDataProviders.InsertL( p->iDpi, ds, storeName ); + p->iDSItem->iAdpLog = adpLog; + CleanupStack::Pop( 3 ); //ds, adpLog, storeName. iDataProviders takes the ownership + + p->CallDSAsyncLC().OpenL( *storeName, *adpLog, p->iStatus ); + + CleanupStack::Pop( 2 ); //CallDSAsyncLC, p + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::OpenFinished +// called when OpenL request is finished. +// Note! when aOperation is CNSmlDSAsyncCallBack::ECanceled or CNSmlDSAsyncCallBack::EFree, +// aDSAO->iDSItem might be NULL. +// ------------------------------------------------------------------------------------------------ +TInt CNSmlDSHostSession::OpenFinishedL( CNSmlDSAsyncCallBack* aDSAO, TCallBackOperation aOperation ) + { + CNSmlDSAsyncCallBackForOpen* p = static_cast ( aDSAO ); + TInt err( aDSAO->iStatus.Int() ); + + switch( aOperation ) + { + case CNSmlDSAsyncCallBack::EFinished: + if ( err == KErrNone ) + { + aDSAO->iDSItem->SetOpened(); + } + else + { + //calling recursively + OpenFinishedL( aDSAO, CNSmlDSAsyncCallBack::ECanceled ); + } + break; + case CNSmlDSAsyncCallBack::ECanceled: + iDataProviders.Remove( p->iDpi, + p->iDSItem ); //aDSAO->iDSItem might be NULL, but remove checks that. + err = KErrNone; + break; + case CNSmlDSAsyncCallBack::EFree: + delete p->iServerId; + p->iServerId = NULL; + delete p->iRemoteDB; + p->iRemoteDB = NULL; + + aDSAO->iPtr = NULL; + break; + default: + User::Leave( KErrUnknown ); + }; + + return err; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CancelRequest +// Cancel the current asynchronous request. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CancelRequestL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + CNSmlDSAsyncRequestHandler* dsao = dsi->iDSAO; + //Note! it is possible, that after deleting dsao, + //dsi may not exist anymore. + dsi = NULL; + + if ( dsao ) + { + delete dsao; + dsao = NULL; + } + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::BeginTransaction +// Starts the transaction mode. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::BeginTransactionL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CSmlDataStore* ds = dsi->iDataStore; + ds->BeginTransactionL(); + dsi->iHostMode = ENSmlTransactionMode; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitTransaction +// Method will be called at the end of a successful transaction. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CommitTransactionL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().CommitTransactionL( dsao->iStatus ); + dsi->iHostMode = ENSmlNormalMode; + CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::RevertTransaction +// Method will be called to abort an ongoing transaction. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::RevertTransactionL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().RevertTransaction( dsao->iStatus ); + dsi->iHostMode = ENSmlNormalMode; + CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::BeginBatch +// Starts the batch mode. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::BeginBatchL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + RBatchItemUidArray* biua= new ( ELeave ) RBatchItemUidArray(); + CleanupRPtrArrayPushL( biua ); + CSmlDataStore* ds = dsi->iDataStore; + ds->BeginBatchL(); + dsi->iHostMode = ENSmlBatchMode; + dsi->iBatchItemUids = biua; + CleanupStack::Pop( biua ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitBatchL +// Method will be called at the end of the batch mode. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CommitBatchL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + RArray* resultArray = new ( ELeave ) RArray; + CleanupStack::PushL( resultArray ); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( + this, dsi, aMessage, CommitBatchRequestFinishedL, resultArray ); + CleanupStack::Pop( resultArray ); //dsao takes ownership + + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().CommitBatchL( *resultArray, dsao->iStatus ); + CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitBatchRequestFinished +// Called when commitBatchL request is finished +// ------------------------------------------------------------------------------------------------ +TInt CNSmlDSHostSession::CommitBatchRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, + TCallBackOperation aOperation ) + { + TInt status ( aDSAO->iStatus.Int() ); + TNSmlDSDataStoreElement* dsi = aDSAO->iDSItem; + RArray* resultArray = reinterpret_cast*>( aDSAO->iPtr ); + + switch( aOperation ) + { + case CNSmlDSAsyncCallBack::EFinished: + dsi->iHostMode = ENSmlNormalMode; + if ( status == KErrNone ) + { + TMemPtr& dest( MemPtrL() ); + TStreamBuffers* sb = dest.StreamBufferLC(); + + // write results + sb->iWrite->WriteInt32L( resultArray->Count() ); + for ( TInt i = 0; i < resultArray->Count(); i++ ) + { + sb->iWrite->WriteInt32L( ( *resultArray )[i] ); + } + // write uids that are added. + if ( dsi->iBatchItemUids ) + { + sb->iWrite->WriteInt32L( dsi->iBatchItemUids->Count() ); + for ( TInt i = 0; i < dsi->iBatchItemUids->Count(); i++ ) + { + TPckgC uid( *( *dsi->iBatchItemUids )[i] ); + sb->iWrite->WriteL( uid ); + } + } + else + { + sb->iWrite->WriteInt32L( 0 ); + } + StreamBufferToChunkL( dest, sb ); + CleanupStack::PopAndDestroy(); //sb + status = aDSAO->iStatus.Int(); + } + break; + case CNSmlDSAsyncCallBack::ECanceled: + break; + case CNSmlDSAsyncCallBack::EFree: + dsi->FreeBatchItemArray(); + resultArray->Close(); + delete resultArray; + aDSAO->iPtr = NULL; + break; + default: + User::Leave( KErrUnknown ); + } + + return status; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CancelBatchL +// Method will be called to abort an ongoing batch mode. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CancelBatchL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CSmlDataStore* ds = dsi->iDataStore; + ds->CancelBatch(); + dsi->iHostMode = ENSmlNormalMode; + dsi->FreeBatchItemArray(); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::SetRemoteDataStoreFormatL +// Sets the Sync Partner Data Format. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::SetRemoteDataStoreFormatL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + CSmlDataStore* ds = dsi->iDataStore; + TMemPtr& ptr( MemPtrL() ); + RReadStream& readStream = ptr.ReadStreamLC(); + + CSmlDataStoreFormat* serverDataStoreFormat = CSmlDataStoreFormat::NewLC( iStringPool, readStream ); + ds->SetRemoteStoreFormatL( *serverDataStoreFormat ); + dsi->setStoreFormat( serverDataStoreFormat ); + CleanupStack::Pop(); //serverDataStoreFormat + CleanupStack::PopAndDestroy(); //readStream + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::SetRemoteMaxObjectSizeL +// Sets the SyncML server Sync Partner maximum object size. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::SetRemoteMaxObjectSizeL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + + TMemPtr& ptr( MemPtrL() ); + TInt tmp(0); + TPckg maxObjectSize( tmp ); + ptr.CopyTo( maxObjectSize ); + ds->SetRemoteMaxObjectSize( maxObjectSize() ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::MaxObjectSizeL +// Gets the Data Store maximum object size which is reported to the SyncML partner. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::MaxObjectSizeL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + + TInt maxObjectSize = ds->MaxObjectSize(); + TPckgC pck( maxObjectSize ); + aMessage.WriteL( 2, pck ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::OpenItemL +// Opens item at Data Store. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::OpenItemL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + CNSmlServerDSHostItem* dshi = DataStoreItemParamsLC(); + + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( + this, dsi, aMessage, OpenItemRequestFinishedL, dshi ); + CleanupStack::Pop( dshi ); //dsao takes ownership + CleanupStack::PushL( dsao ); + + dsao->CallDSAsyncLC().OpenItemL( + dshi->Uid(), dshi->FieldChange(), dshi->Size(), dshi->ParentUid(), + dshi->iMimeTypePtr, dshi->iMimeVerPtr, + dsao->iStatus ); + + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::OpenItemRequestFinishedL +//Called when OpenItemL request is finished. +// ------------------------------------------------------------------------------------------------ +TInt CNSmlDSHostSession::OpenItemRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, + TCallBackOperation aOperation ) + { + TInt status( aDSAO->iStatus.Int() ); + CNSmlServerDSHostItem* dshi = reinterpret_cast( aDSAO->iPtr ); + + switch( aOperation ) + { + case CNSmlDSAsyncCallBack::EFinished: + if ( status == KErrNone ) + { + dshi->SetMimeTypeL( dshi->iMimeTypePtr ); + dshi->SetMimeVerL( dshi->iMimeVerPtr ); + WriteDataStoreItemParamsL( dshi ); + } + break; + case CNSmlDSAsyncCallBack::ECanceled: + status = KErrNone; + break; + case CNSmlDSAsyncCallBack::EFree: + delete dshi; + aDSAO->iPtr = NULL; + break; + default: + User::Leave( KErrUnknown ); + } + + return status; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DataStoreItemParamsLC +// ------------------------------------------------------------------------------------------------ +CNSmlDSHostSession::CNSmlServerDSHostItem* CNSmlDSHostSession::DataStoreItemParamsLC() + { + CNSmlServerDSHostItem* dshi = CNSmlServerDSHostItem::NewLC(); + TMemPtr& ptr( MemPtrL() ); + RReadStream& mrs = ptr.ReadStreamLC(); + + dshi->InternalizeL( mrs ); + + CleanupStack::PopAndDestroy(); //mrs + return dshi; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::WriteDataStoreItemParamsL +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::WriteDataStoreItemParamsL( CNSmlDSHostItem* dshi ) + { + TMemPtr& ptr( MemPtrL() ); + RWriteStream& mws = ptr.WriteStreamLC(); + dshi->ExternalizeL( mws ); + mws.CommitL(); + CleanupStack::PopAndDestroy(); //mws + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CreateItemL +// Creates new item to Data Store. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CreateItemL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + CNSmlServerDSHostItem* dshi = DataStoreItemParamsLC(); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( + this, dsi, aMessage, CreateItemRequestFinishedL, dshi ); + CleanupStack::Pop( dshi ); //dsao takes ownership + CleanupStack::PushL( dsao ); + + TSmlDbItemUid* uid = NULL; + + if ( dsi->iHostMode == ENSmlBatchMode ) + { + uid = new ( ELeave ) TSmlDbItemUid(); + CleanupStack::PushL( uid ); + dsi->iBatchItemUids->AppendL( uid ); + CleanupStack::Pop( uid ); + } + else{ + uid = &dsi->iCreatedUid; + } + + *uid = dshi->Uid(); + dshi->iCreateItemUid = uid; + + dsao->CallDSAsyncLC().CreateItemL( + *uid, dshi->Size(), dshi->ParentUid(), *dshi->MimeType(), + *dshi->MimeVer(), dsao->iStatus ); + + CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CreateItemRequestFinishedL +// Called when CreateItemL request is finished. +// ------------------------------------------------------------------------------------------------ +TInt CNSmlDSHostSession::CreateItemRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, + TCallBackOperation aOperation ) + { + TInt status( aDSAO->iStatus.Int() ); + CNSmlServerDSHostItem* dshi = reinterpret_cast( aDSAO->iPtr ); + + switch( aOperation ) + { + case CNSmlDSAsyncCallBack::EFinished: + if ( status == KErrNone ) + { + dshi->SetUid( *dshi->iCreateItemUid ); + WriteDataStoreItemParamsL( dshi ); + } + break; + case CNSmlDSAsyncCallBack::ECanceled: + status = KErrNone; + break; + case CNSmlDSAsyncCallBack::EFree: + delete dshi; + aDSAO->iPtr = NULL; + break; + default: + User::Leave( KErrUnknown ); + }; + + return status; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::ReplaceItemL +// Replaces old item at Data Store. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::ReplaceItemL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + CNSmlDSHostItem* dshi = DataStoreItemParamsLC(); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().ReplaceItemL( + dshi->Uid(), dshi->Size(), dshi->ParentUid(), dshi->FieldChange(), dsao->iStatus ); + CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao + CleanupStack::PopAndDestroy(); //dshi + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::ReadItemL +// Reads data from item at Data Store. Item must be opened before this method can be called. +// This method is called until aBuffer is not used totally or method leaves with KErrEof. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::ReadItemL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + TMemPtr& mem( MemPtrL() ); + TInt32 sizeBytes(0); + + TPckg bytesToRead( sizeBytes ); + mem.CopyTo( bytesToRead ); + + TInt chunkSize( mem.Size() - sizeof( TInt ) ); + + if ( sizeBytes > chunkSize ) + { + sizeBytes = chunkSize; + } + + TPtr8 ptr( mem.Mid( sizeof( TInt ), sizeBytes ) ); + ds->ReadItemL( ptr ); + + TPckgC ReadBytes( ptr.Size() ); + mem.Des().Copy( ReadBytes ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::WriteItemL +// Writes data to item to Data Provider. CreateItemL or ReplaceItemL method must be called before +// this method can be called. This method is called until all data to current item is written. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::WriteItemL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + TMemPtr& mem( MemPtrL() ); + + TInt32 tmp(0); + TPckg bytesToWrite( tmp ); + mem.CopyTo( bytesToWrite ); + + TPtr8 ptr( mem.Mid( 4, bytesToWrite() ) ); + ptr.SetLength( ptr.MaxLength() ); + + ds->WriteItemL( ptr ); + + TPckgC bytesWritten( ptr.Size() ); + mem.Des().Copy( bytesWritten ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitItemL +// After item is written to Data Provider it can be saved to the Data Store. +// This method can be called just after WriteItemL method. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CommitItemL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( + this, dsi, aMessage, CommitItemRequestFinishedL ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().CommitItemL( dsao->iStatus ); + CleanupStack::Pop(2); //CallDSAsyncLC, dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitItemRequestFinishedL +// Called when CommitItemL request is finished. +// ------------------------------------------------------------------------------------------------ +TInt CNSmlDSHostSession::CommitItemRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, + TCallBackOperation aOperation ) + { + TInt status( aDSAO->iStatus.Int() ); + + switch( aOperation ) + { + case CNSmlDSAsyncCallBack::EFinished: + if ( status == KErrNone ) + { + TNSmlDSDataStoreElement* dsi = aDSAO->iDSItem; + + if ( dsi->iHostMode != ENSmlBatchMode ) + { + TSmlDbItemUid uid = dsi->iCreatedUid; + TPckgC pck( uid ); + aDSAO->iMessage.WriteL( 2, pck ); + } + } + break; + case CNSmlDSAsyncCallBack::ECanceled: + status = KErrNone; + break; + case CNSmlDSAsyncCallBack::EFree: + break; + default: + User::Leave( KErrUnknown ); + } + + return status; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CloseItem +// Closes opened item. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CloseItemL( const RMessage2& aMessage ) + { + DataStoreL( aMessage )->CloseItem(); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::MoveItemL +// Moves item to new location. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::MoveItemL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSHostItem* dshi = DataStoreItemParamsLC(); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().MoveItemL( dshi->Uid(), dshi->ParentUid(), dsao->iStatus ); + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + CleanupStack::PopAndDestroy(); //dshi + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DeleteItemL +// Deletes one item at Data Store permanently. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::DeleteItemL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSHostItem* dshi = DataStoreItemParamsLC(); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().DeleteItemL( dshi->Uid(), dsao->iStatus ); + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + CleanupStack::PopAndDestroy(); //dshi + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::SoftDeleteItemL +// Soft deletes one item at Data Store. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::SoftDeleteItemL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSHostItem* dshi = DataStoreItemParamsLC(); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().SoftDeleteItemL( dshi->Uid(), dsao->iStatus ); + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + CleanupStack::PopAndDestroy(); //dshi + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DeleteAllItemsL +// Deletes all items at Data Store permanently. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::DeleteAllItemsL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().DeleteAllItemsL( dsao->iStatus ); + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::HasSyncHistoryL +// Checks if the Data Store has sync history. If not then slow sync is proposed to Sync Partner. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::HasSyncHistoryL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + TPckgC pck( TBool( ds->HasSyncHistory() ) ); + aMessage.WriteL( 2, pck ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::AddedItemsL +// The Data Provider returns UIDs of items that are added after previous synchronization. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::AddedItemsL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + + const MSmlDataItemUidSet& dius = ds->AddedItems(); + RNSmlDbItemModificationSet dbims; + CleanupClosePushL( dbims ); + + dbims.AddGroupL( dius, TNSmlDbItemModification::ENSmlDbItemAdd ); + + TMemPtr& dest( MemPtrL() ); + dest.AdjustChunkIfNeededL( dbims.StreamSize() ); + RWriteStream& wStream = dest.WriteStreamLC(); + dbims.ExternalizeL( wStream ); + wStream.CommitL(); + CleanupStack::PopAndDestroy(2); //wStream, dbims + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DeletedItemsL +// The Data Provider returns UIDs of items that are deleted after previous synchronization. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::DeletedItemsL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + + const MSmlDataItemUidSet& dius = ds->DeletedItems(); + RNSmlDbItemModificationSet dbims; + CleanupClosePushL( dbims ); + + dbims.AddGroupL( dius, TNSmlDbItemModification::ENSmlDbItemDelete ); + + TMemPtr& dest( MemPtrL() ); + dest.AdjustChunkIfNeededL( dbims.StreamSize() ); + RWriteStream& wStream = dest.WriteStreamLC(); + dbims.ExternalizeL( wStream ); + wStream.CommitL(); + CleanupStack::PopAndDestroy(2); //wStream, dbims + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::SoftDeleteItemsL +// The Data Provider returns UIDs of items that are soft deleted after previous synchronization. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::SoftDeleteItemsL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + + const MSmlDataItemUidSet& dius = ds->SoftDeletedItems(); + RNSmlDbItemModificationSet dbims; + CleanupClosePushL( dbims ); + + dbims.AddGroupL( dius, TNSmlDbItemModification::ENSmlDbItemSoftDelete ); + + TMemPtr& dest( MemPtrL() ); + dest.AdjustChunkIfNeededL( dbims.StreamSize() ); + RWriteStream& wStream = dest.WriteStreamLC(); + dbims.ExternalizeL( wStream ); + wStream.CommitL(); + CleanupStack::PopAndDestroy(2); //wStream, dbims + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::ModifiedItemsL +// The Data Provider returns UIDs of items that are modified after previous synchronization. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::ModifiedItemsL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + + const MSmlDataItemUidSet& dius = ds->ModifiedItems(); + RNSmlDbItemModificationSet dbims; + CleanupClosePushL( dbims ); + + dbims.AddGroupL( dius, TNSmlDbItemModification::ENSmlDbItemModify ); + + TMemPtr& dest( MemPtrL() ); + dest.AdjustChunkIfNeededL( dbims.StreamSize() ); + RWriteStream& wStream = dest.WriteStreamLC(); + dbims.ExternalizeL( wStream ); + wStream.CommitL(); + CleanupStack::PopAndDestroy(2); //wStream, dbims + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::MovedItemsL +// The Data Provider returns UIDs of items that are moved after previous synchronization. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::MovedItemsL( const RMessage2& aMessage ) + { + CSmlDataStore* ds = DataStoreL( aMessage ); + + const MSmlDataItemUidSet& dius = ds->MovedItems(); + RNSmlDbItemModificationSet dbims; + CleanupClosePushL( dbims ); + + dbims.AddGroupL( dius, TNSmlDbItemModification::ENSmlDbItemMove ); + + TMemPtr& dest( MemPtrL() ); + dest.AdjustChunkIfNeededL( dbims.StreamSize() ); + RWriteStream& wStream = dest.WriteStreamLC(); + dbims.ExternalizeL( wStream ); + wStream.CommitL(); + CleanupStack::PopAndDestroy(2); //wStream, dbims + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::AllItemsL +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::AllItemsL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSChangedItemsFetcher* dsao = CNSmlDSChangedItemsFetcher::NewLC( + this, dsi, aMessage, AllItemsRequestFinishedL ); + dsao->FetchAllChangedItemsL(); + CleanupStack::Pop(); //dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::AllItemsRequestFinished +// Called when AllItems request is finished. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::AllItemsRequestFinishedL( CNSmlDSChangedItemsFetcher* aDSAO ) + { + TMemPtr& dest( MemPtrL() ); + const RNSmlDbItemModificationSet* mods = aDSAO->ChangedItems(); + dest.AdjustChunkIfNeededL( mods->StreamSize() ); + RWriteStream& wStream = dest.WriteStreamLC(); + mods->ExternalizeL( wStream ); + wStream.CommitL(); + CleanupStack::PopAndDestroy(); //wStream + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::ResetChangeInfoL +// Reset change info from the Data Provider. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::ResetChangeInfoL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().ResetChangeInfoL( dsao->iStatus ); + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitChangeInfoL +// This method is called after some changes are synchronized to Sync Partner. If some changes +// were synchronized correctly then those UIDs are included to aItems. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CommitChangesL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + + CNSmlDataItemUidSet* dius = new ( ELeave ) CNSmlDataItemUidSet(); + CleanupStack::PushL( dius ); + TMemPtr& ptr( MemPtrL() ); + RReadStream& readStream = ptr.ReadStreamLC(); + dius->InternalizeL( readStream ); + CleanupStack::PopAndDestroy(); //readStream + + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( + this, dsi, aMessage, CommitChangesRequestFinishedL, dius ); + CleanupStack::Pop( dius ); //dsao takes the ownership. + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().CommitChangeInfoL( dsao->iStatus, *dius ); + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + } +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitItemRequestFinishedL +// This method is called after CommitChangesL request is finished. +// ------------------------------------------------------------------------------------------------ +TInt CNSmlDSHostSession::CommitChangesRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, + TCallBackOperation aOperation ) + { + TInt status( aDSAO->iStatus.Int() ); + CNSmlDataItemUidSet* dius = reinterpret_cast( aDSAO->iPtr ); + + switch( aOperation ) + { + case CNSmlDSAsyncCallBack::EFinished: + break; + case CNSmlDSAsyncCallBack::ECanceled: + status = KErrNone; + break; + case CNSmlDSAsyncCallBack::EFree: + delete dius; + aDSAO->iPtr = NULL; + break; + default: + User::Leave( KErrUnknown ); + } + + return status; + + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::CommitAllChangesL +// This method is called after some changes are synchronized to Sync Partner. This method is used if +// all changes were synchronized correctly. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::CommitAllChangesL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage ); + CleanupStack::PushL( dsao ); + dsao->CallDSAsyncLC().CommitChangeInfoL( dsao->iStatus ); + CleanupStack::Pop(2); //CallDSAsyncLC(), dsao + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::UpdateServerIdL +// Updates server id to adapter log. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::UpdateServerIdL( const RMessage2& /*aMessage*/ ) + { + TMemPtr& ptr( MemPtrL() ); + RReadStream& readStream = ptr.ReadStreamLC(); + + HBufC* oldServerId = HBufC::NewLC( readStream, readStream.ReadUint32L() ); + HBufC* newValue = HBufC::NewLC( readStream, readStream.ReadUint32L() ); + + CNSmlAdapterLog* adpLog = CNSmlAdapterLog::NewLC(); + + adpLog->SetServerIdL( *oldServerId, *newValue ); + + CleanupStack::PopAndDestroy( 4 ); //adpLog, newValue, oldServerId, readStream + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DataProviderL +// ------------------------------------------------------------------------------------------------ +CSmlDataProvider* CNSmlDSHostSession::DataProviderL( TSmlDataProviderId aId ) + { + CSmlDataProvider* dp = iDataProviders.DataProvider( aId ); + if ( !dp ) + { + User::Leave( ENSmlDSHostServerErrDPNotCreated ); + } + return dp; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DataProviderItemL +// ------------------------------------------------------------------------------------------------ +TNSmlDSDataProviderElement* CNSmlDSHostSession::DataProviderItemL( TSmlDataProviderId aId ) + { + TNSmlDSDataProviderElement* dpi = iDataProviders.DataProviderElement( aId ); + if ( !dpi ) + { + User::Leave( ENSmlDSHostServerErrDPNotCreated ); + } + return dpi; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DataStoreL +// ------------------------------------------------------------------------------------------------ +CSmlDataStore* CNSmlDSHostSession::DataStoreL( const RMessage2& aMessage ) + { + TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage ); + return dsi->iDataStore; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DataStoreItemL +// ------------------------------------------------------------------------------------------------ +TNSmlDSDataStoreElement* CNSmlDSHostSession::DataStoreItemL( const RMessage2& aMessage ) + { + HBufC* storeName = DataStoreNameLC( aMessage ); + TNSmlDSDataStoreElement* dsi = iDataProviders.DataStoreElement( + iDataProviders.DataProviderElement( aMessage.Int0() ), *storeName ); + + if ( !dsi ) + { + User::Leave( ENSmlDSHostServerErrDSNotOpened ); + } + + CleanupStack::PopAndDestroy(); //storeName + + return dsi; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::HasDataStoreL +// ------------------------------------------------------------------------------------------------ +TBool CNSmlDSHostSession::HasDataStoreL( const RMessage2& aMessage ) + { + HBufC* storeName = DataStoreNameLC( aMessage ); + TNSmlDSDataStoreElement* dsi = iDataProviders.DataStoreElement( + iDataProviders.DataProviderElement( aMessage.Int0() ), *storeName ); + + CleanupStack::PopAndDestroy(); //storeName + return ( dsi != NULL ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::DataStoreNameLC +// ------------------------------------------------------------------------------------------------ +HBufC* CNSmlDSHostSession::DataStoreNameLC( const RMessage2& aMessage ) + { + TInt desLength = aMessage.GetDesLength( 1 ); + if ( desLength < 0 ) + { + //if desLength negative, contains system-wide error code. + User::Leave( desLength ); + } + HBufC* storeName = HBufC::NewLC( desLength ); + TPtr store( storeName->Des() ); + aMessage.ReadL( 1, store ); + return storeName; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::InternalizeFiltersL +// Read filters from stream. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::InternalizeFiltersL( RReadStream& aStream, RPointerArray& aFilters ) + { + + TInt count( aStream.ReadInt32L() ); + + for ( TInt i = 0; i < count; i++ ) + { + CSyncMLFilter* filter = CSyncMLFilter::NewLC( aStream ); + aFilters.AppendL( filter ); + CleanupStack::Pop(); // filter + } + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::ExternalizeFiltersL +// Write filters to stream. +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::ExternalizeFiltersL( RWriteStream& aStream, const RPointerArray& aFilters ) + { + TInt count( aFilters.Count() ); + aStream.WriteInt32L( count ); + for ( TInt i(0); i < count; i++ ) + { + aFilters[i]->ExternalizeL( aStream ); + } + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::PanicClient +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::PanicClient( const RMessage2& aMessage, TInt aReason ) const + { + _DBG_FILE( "CNSmlDSHostSession::PanicClient(): begin " ); + aMessage.Panic( _L( "CNSmlDSHostSession" ), aReason ); + _DBG_FILE( "CNSmlDSHostSession::PanicClient(): end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::MemPtrL +// ------------------------------------------------------------------------------------------------ +CNSmlDSHostSession::TMemPtr& CNSmlDSHostSession::MemPtrL() + { + if ( iMemPtr.iChunk.Handle() == 0 || !iMemPtr.iChunk.IsWritable() ) + { + User::Leave( KErrBadHandle ); + } + return iMemPtr; + } + +// ------------------------------------------------------------------------------------------------ +// CNSmlDSHostSession::StreamBufferToChunkL +// ------------------------------------------------------------------------------------------------ +void CNSmlDSHostSession::StreamBufferToChunkL( TMemPtr& aMemPtr, TStreamBuffers* aSb ) + { + aSb->iWrite->CommitL(); + aMemPtr.AdjustChunkIfNeededL( aSb->iBuffer->Size() ); + RWriteStream& wStream = aMemPtr.WriteStreamLC(); + wStream.WriteL( *aSb->iRead ); + wStream.CommitL(); + CleanupStack::PopAndDestroy(); //wStream + } + +// End of File