FCL/sf/app/contentcontrol: comparison omads/omadsextensions/adapters/contacts/src/NSmlContactsDataStore.cpp

equal deleted inserted replaced

-:8e7494275d3a
+:4f0867e42d62
 #include <data_caging_path_literals.hrh>
 #include <SmlDataFormat.h>
 #include <SmlDataProvider.h>
 #include <e32property.h>
 #include <DataSyncInternalPSKeys.h>
-#include <nsmlcontactsdatastoreextension.h>
+#include <e32hashtab.h>
-#include <NSmlDataModBase.h>
-#include <nsmlcontactsdatastore.h>
+#include <CVPbkContactStoreUriArray.h>
+#include <VPbkContactStoreUris.h>
+#include <TVPbkContactStoreUriPtr.h>
+#include <MVPbkContactStoreList.h>
+#include <MVPbkContactStoreProperties.h>
+#include <MVPbkStoreContactProperties.h>
+#include <MVPbkViewContact.h>
+#include <MVPbkStoreContact.h>
+#include <MVPbkStoreContact2.h>
+#include <MVPbkFieldType.h>
+#include <MVPbkContactFieldTextData.h>
+#include <CVPbkContactFieldIterator.h>
+#include <CVPbkContactViewDefinition.h>
+#include <MVPbkContactLink.h>
+#include <s32mem.h>
+#include <NSmlContactsDataStore.h>
+#include "NSmlContactsModsFetcher.h"
 #include "nsmldebug.h"
 #include "nsmlconstants.h"
+#include <NSmlDataModBase.h>
+#include "nsmlcontactsdefs.h"
 #include "nsmldsimpluids.h"
 #include "nsmlsnapshotitem.h"
 #include "nsmlchangefinder.h"
+#include <VPbkEng.rsg>
 #ifndef __WINS__
 // This lowers the unnecessary compiler warning (armv5) to remark.
 // "Warning:  #174-D: expression has no effect..." is caused by
 // DBG_ARGS8 macro in no-debug builds.
 	_DBG_FILE("CNSmlContactsDataStore::NewL: BEGIN");
 	CNSmlContactsDataStore* self = new ( ELeave ) CNSmlContactsDataStore();
 	CleanupStack::PushL(self);
 	self->ConstructL();
-	CleanupStack::Pop(); // self
+	CleanupStack::Pop(self); // self
 	_DBG_FILE("CNSmlContactsDataStore::NewL: END");
 	return self;
 	}
 // ----------------------------------------------------------------------------
 // CNSmlContactsDataStore::CNSmlContactsDataStore()
 // ----------------------------------------------------------------------------
-EXPORT_C CNSmlContactsDataStore::CNSmlContactsDataStore() : iKey( TKeyArrayFix( _FOFF( TNSmlSnapshotItem,ItemId() ),ECmpTInt ))
+EXPORT_C CNSmlContactsDataStore::CNSmlContactsDataStore() :
+	iKey( TKeyArrayFix( _FOFF( TNSmlSnapshotItem,ItemId() ),ECmpTInt )),
+	iContactManager(NULL),
+	iStore(NULL),
+	iIdConverter(NULL),
+	iContactViewBase(NULL),
+	iSize(NULL),
+	iBuf(NULL),
+	iVCardEngine(NULL),
+	iContactLnks(NULL)
 	{
 	_DBG_FILE("CNSmlContactsDataStore::CNSmlContactsDataStore(): begin");
 	iSyncHistory = EFalse;
 	iSnapshotRegistered = EFalse;
 	iServerMaxObjectSize = 0; // Maximum size default value
 	iItemPos = -1;
 	iModificationCount = KNSmlCompactAfterChanges;
 	iState = ENSmlClosed;
 	iStoreName = NULL;
+	iRetCommand = KErrNone;
-	iDrive = -1;
+	iLastOperation = ENSmlNone;
+	if(iDeleteAllOperation)
+	    {
+	    delete iDeleteAllOperation;
+	    iDeleteAllOperation = NULL;
+	    }
 	_DBG_FILE("CNSmlContactsDataStore::CNSmlContactsDataStore(): end");
 	}
 // ----------------------------------------------------------------------------
 // CNSmlContactsDataStore::ConstructL()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::ConstructL()
 	{
-	_DBG_FILE("CNSmlContactsDataStore::CNSmlContactsDataStore(): begin");
+	_DBG_FILE("CNSmlContactsDataStore::ConstructL(): begin");
-	ConstructL( KNSmlContactStoreNameForDefaultDB );
+	ConstructL( ( VPbkContactStoreUris::DefaultCntDbUri() ), KLegacySymbianDatabase );
 	_DBG_FILE("CNSmlContactsDataStore::ConstructL(): end");
 	}
 // ----------------------------------------------------------------------------
 // CNSmlContactsDataStore::ConstructL()
 // ----------------------------------------------------------------------------
-EXPORT_C void CNSmlContactsDataStore::ConstructL( const TDesC& aStoreName )
+EXPORT_C void CNSmlContactsDataStore::ConstructL(
+const TDesC& aStoreName, const TDesC& aLegacyStore )
 {
-_DBG_FILE("CNSmlContactsDataStore::CNSmlContactsDataStore(): begin");
+_DBG_FILE("CNSmlContactsDataStore::ConstructL(): begin");
-//TODO: NOT RESPECTING THE aStoreName VALUE FOR 10.1
 User::LeaveIfError( iRfs.Connect() );
 iStringPool.OpenL();
 // Uid Sets
 iNewUids = new (ELeave) CNSmlDataItemUidSet();
 iDeletedUids = new (ELeave) CNSmlDataItemUidSet();
 iReplacedUids = new (ELeave) CNSmlDataItemUidSet();
 // Create iDataMod
 // This should be done after OpenL if there are more than one database
 iDataMod = new (ELeave) CNSmlVCardMod();
-iContactsDataStoreExtension = NULL;
 SetOwnStoreFormatL();
+// open  contact database
+CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewLC();
+uriArray->AppendL( TVPbkContactStoreUriPtr( aStoreName ));
-// TODO: Determine the Default StoreName
+iContactManager = CVPbkContactManager::NewL(*uriArray);
-iDefaultStoreName = HBufC::NewL(KNSmlDefaultStoreNameMaxSize);
+CleanupStack::PopAndDestroy(uriArray);
-*iDefaultStoreName = KNSmlContactStoreNameForDefaultDB;
+//Default store name
+iDefaultStoreName = aStoreName.AllocL();
-iSnapshot = new (ELeave) CArrayFixSeg<TNSmlSnapshotItem>(KNSmlContactsGranularity);
+//Fill iPacketStoreName buffer with legacy store name
-iCntUidList = new(ELeave) CArrayFixFlat<TUid>(KNSmlContactsGranularity);
+TBuf<KOldSymbianDBLength> dataBase(aLegacyStore);
+iPacketStoreName = HBufC::NewL(dataBase.Length());
+TPtr pktStorePtr(iPacketStoreName->Des());
+pktStorePtr.Copy(dataBase);
+iDeleteAllOperation = NULL;
 _DBG_FILE("CNSmlContactsDataStore::ConstructL(): end");
 }
 // ----------------------------------------------------------------------------
 // CNSmlContactsDataStore::~CNSmlContactsDataStore()
 // ----------------------------------------------------------------------------
 	delete iStoreFormat; // SetOwnStoreFormatL creates
 	iStringPool.Close();
 	iRfs.Close();
+	iWriteStream.Close();
+	iReadStream.Close();
+	delete iBuf;
 	if ( iChangeFinder )
 		{
 		TRAP_IGNORE( iChangeFinder->CloseL() );
 		delete iChangeFinder;
-		}
+		iChangeFinder = NULL;
+		}
-	if( iContactsDataStoreExtension )
+	if(iIdConverter)
+		{
+		delete iIdConverter;
+		iIdConverter = NULL;
+		}
+	if(iContactLnks)
+		{
+delete iContactLnks;
+		iContactLnks = NULL;
+		}
+	if(iContactViewBase)
 	    {
-delete iContactsDataStoreExtension;
+	    delete iContactViewBase;
-iContactsDataStoreExtension = NULL;
+	    iContactViewBase = NULL;
 	    }
+	if ( iContactsModsFetcher )
+		{
+		iContactsModsFetcher->CancelRequest();
+		delete iContactsModsFetcher;
+		iContactsModsFetcher = NULL;
+		}
+	if ( iContactManager )
+		{
+			if(iStore)
+			{
+			iStore->Close( *this );
+			}
+	    delete iContactManager;
+	    iContactManager = NULL;
+		}
+	delete iVCardEngine;
+	//  Delete UidSets
+	//
 	delete iNewUids;
 	delete iDeletedUids;
 	delete iSoftDeletedUids;
 	delete iMovedUids;
 	delete iReplacedUids;
-	delete iSnapshot;
+	//
-delete iCntUidList;
+	//	Empty BufferItemList if any
-//
+	//
-//	Empty BufferItemList if any
+	if ( iContactsBufferItemList.Count() > 0 )
-//
+		{
-if ( iContactsBufferItemList.Count() > 0 )
+		if ( iContactsBufferItemList[iContactsBufferItemList.Count() - 1]->iItemData == iItemData )
-{
+			{
-if ( iContactsBufferItemList[iContactsBufferItemList.Count() - 1]->iItemData == iItemData )
+			iItemData = NULL;
-{
+			}
-iItemData = NULL;
+		}
-}
-}
 	iContactsBufferItemList.ResetAndDestroy();
 	delete iDataMod;
+	delete iMergeItem;
 	if(iItemData)
 	{
 	    if(iItemData->Size() > 0 )
 	        {
 		    delete iItemData;
 		{
 		delete iItemDataAddBatch;
 		}
 	delete iDefaultStoreName;
+	delete iPacketStoreName;
 	delete iStoreName;
 	iAddResultArray.Close();
+	if(iDeleteAllOperation)
+	    {
+	    delete iDeleteAllOperation;
+	    iDeleteAllOperation = NULL;
+	    }
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoOpenL(const TDesC& 		  aStoreName,
 //									    MSmlSyncRelationship& aContext,
 //									    TRequestStatus& 	  aStatus)
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoOpenL( const TDesC& aStoreName,
-MSmlSyncRelationship& aContext,
+									MSmlSyncRelationship& aContext,
-TRequestStatus& aStatus )
+									TRequestStatus& aStatus )
 	{
 	DBG_ARGS(_S("CNSmlContactsDataStore::DoOpenL(): '%S' begin"), &aStoreName);
 	iCallerStatus = &aStatus;
 	*iCallerStatus = KRequestPending;
 		{
 		User::RequestComplete( iCallerStatus, KErrInUse );
 		return;
 		}
-	RFs::CharToDrive( KNSmlDriveC()[0], iDrive );
+	if( RFs::CharToDrive(aStoreName[0], iDrive) != KErrNone )
-	/*if( RFs::CharToDrive(aStoreName[0], iDrive) != KErrNone )
 		{
 		RFs::CharToDrive( KNSmlDriveC()[0], iDrive );
-		}*/
+		}
 	iOpened = EFalse;
 	if( iStoreName )
 		{
 		delete iStoreName;
 		iStoreName = NULL;
 		}
-	if ( iContactsDataStoreExtension )
+		if ( iChangeFinder )
-		{
-		delete iContactsDataStoreExtension;
-		iContactsDataStoreExtension = NULL;
-		}
-	TInt err( KErrNone );
-	// TODO:Change the storename later
-	TRAP( err, iContactsDataStoreExtension = CNsmlContactsDataStoreExtension::NewL( KNSmlContactStoreNameForDefaultDB() ) );
-	if( err == KErrNone )
-		{
-		iOpened = ETrue;
-		iStoreName = aStoreName.AllocL();
-		iOpenedStoreId = iContactsDataStoreExtension->MachineIdL();
-		}
-	else
-		{
-		DBG_ARGS(_S("CNSmlContactsDataStore::DoOpenL(): result = %d"), err); // Cnt open = err
-		iOpened = EFalse;
-		delete iStoreName;
-		iStoreName = NULL;
-		iOpenedStoreId = 0;
-		User::RequestComplete( iCallerStatus, err );
-		_DBG_FILE("CNSmlContactsDataStore::DoOpenL(): CONTACTS FILE NOTFOUND end");
-		return;
-		}
-	if ( iChangeFinder )
 		{
 		iChangeFinder->CloseL();
 		delete iChangeFinder;
 		iChangeFinder = NULL;
 		}
-	iChangeFinder = CNSmlChangeFinder::NewL( aContext, iKey, iSyncHistory, KNSmlContactsAdapterImplUid );
+	// The Change finder maintains a list of all changes to the database.
+	iChangeFinder = CNSmlChangeFinder::NewL(
-	iState = ENSmlOpenAndWaiting;
+					 aContext, iKey, iSyncHistory, KNSmlContactsAdapterImplUid );
-	err = FetchModificationsL();
+	iState = ENSmlOpenAndWaiting;
-	DBG_ARGS(_S("CNSmlContactsDataStore::DoOpenL(): Error: %d"), err);
+	//find and open the store
+	if ( aStoreName == KNSmlContactStoreNameForDefaultDB )
-	User::RequestComplete( iCallerStatus, err );
+	    {
+	iStore = iContactManager->ContactStoresL().Find(
+	TVPbkContactStoreUriPtr(*iDefaultStoreName));
+	    }
+	else
+	   {
+	    iStore = iContactManager->ContactStoresL().Find(
+	TVPbkContactStoreUriPtr(aStoreName));
+	    }
+	iStore->OpenL(*this);
+	iStoreName = aStoreName.AllocL();
+	iVCardEngine = CVPbkVCardEng::NewL( *iContactManager );
+	iIdConverter = CVPbkContactIdConverter::NewL(*iStore );
+	if ( iContactsModsFetcher )
+		{
+		iContactsModsFetcher->CancelRequest();
+		delete iContactsModsFetcher;
+		iContactsModsFetcher = NULL;
+		}
+	iContactsModsFetcher = CreateModsFetcherL();
+#ifdef __NSML_MODULETEST__
+	CActiveScheduler::Start();
+#endif
 	_DBG_FILE("CNSmlContactsDataStore::DoOpenL(): end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoCancelRequest()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoCancelRequest()
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoCancelRequest(): begin");
+	if(iLastOperation == ENSMLDeleteAllOp)
+	    {
+	    if(iDeleteAllOperation)
+	        {
+	        delete iDeleteAllOperation;
+	        iDeleteAllOperation = NULL;
+	        }
+	    if( iChangeFinder )
+	        {
+TRAP_IGNORE(iChangeFinder->ResetL());
+	        }
+	    iSnapshotRegistered = EFalse;
+	    if(iContactLnks)
+	        {
+	        delete iContactLnks;
+	        iContactLnks = NULL;
+			iContactLink = NULL;
+	        }
+	    if(iContactViewBase)
+	        {
+	        delete iContactViewBase;
+	        iContactViewBase = NULL;
+	        }
+	    User::RequestComplete( iCallerStatus, KErrCancel );
+	    }
+		if(iContactsModsFetcher)
+		{
+		iContactsModsFetcher->CancelRequest();
+		}
 	_DBG_FILE("CNSmlContactsDataStore::DoCancelRequest(): NOT NEEDED end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DefaultStoreNameL()
 // ----------------------------------------------------------------------------
 EXPORT_C const TDesC& CNSmlContactsDataStore::DefaultStoreNameL() const
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DefaultStoreNameL(): begin");
 	if ( !iDefaultStoreName )
 		{
 		return KNullDesC;
 		}
 	_DBG_FILE("CNSmlContactsDataStore::DefaultStoreNameL(): end");
-	return *iDefaultStoreName;
+	//The engine methods that create syncml packet, use this information in Database fields
+	return *iPacketStoreName;
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoBeginTransactionL()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoBeginBatchL()
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoBeginBatchL(): begin");
 	iBatchMode = ETrue;			// SUPPORTED on Contacts
-	if( iItemDataAddBatch )
-		{
-		iItemDataAddBatch->Reset();
-		}
 	_DBG_FILE("CNSmlContactsDataStore::DoBeginBatchL(): end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoCommitBatchL()
 // ----------------------------------------------------------------------------
-EXPORT_C void CNSmlContactsDataStore::DoCommitBatchL( RArray<TInt>& aResultArray,
+EXPORT_C void CNSmlContactsDataStore::DoCommitBatchL( RArray<TInt>& aResultArray, TRequestStatus& aStatus )
-TRequestStatus& aStatus )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoCommitBatchL(): begin");
 	iCallerStatus = &aStatus;
 	*iCallerStatus = KRequestPending;
 		_DBG_FILE("CNSmlContactsDataStore::DoCommitBatchL(): NOT ON BATCH MODE end");
 		return;
 		}
 //
 // Go through Buffer and execute all commands return aResultArray
-// If none of commands succeeds KErrGeneral returned as status otherwise KErrNone returned
 //
-	TInt err = KErrNone;
+	iResultArray = &aResultArray;
-	TRAPD( leavecode, err = ExecuteBufferL(aResultArray) );
+	iIndex = 0;
+	TRAPD( leavecode,ExecuteBufferL() );
 	if( leavecode != KErrNone )
 		{
-		err = leavecode;
+		User::RequestComplete( iCallerStatus, leavecode );
 		}
-//
-// Empty Buffer
-//
-	iContactsBufferItemList.ResetAndDestroy();
-	if( iItemDataAddBatch )
-		{
-		iItemDataAddBatch->Reset();
-		}
-	iBatchMode = EFalse; // All data handled
-	User::RequestComplete( iCallerStatus, err );
 	_DBG_FILE("CNSmlContactsDataStore::DoCommitBatchL(): end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::ExecuteBufferL()
 // ----------------------------------------------------------------------------
-EXPORT_C TInt CNSmlContactsDataStore::ExecuteBufferL(RArray<TInt>& aResultArray)
+EXPORT_C void CNSmlContactsDataStore::ExecuteBufferL()
-{
+	{
-_DBG_FILE("CNSmlContactsDataStore::ExecuteBufferL()");
+	_DBG_FILE("CNSmlContactsDataStore::ExecuteBufferL(): begin");
-return DoExecuteBufferL( aResultArray );
-}
+	TInt  retCommand( KErrNone );
+	//
+	// Loop through buffered commands
+	//
+		if( iIndex < iContactsBufferItemList.Count())
+		{
+		if( iContactsBufferItemList[iIndex]->iStatus!= KNSmlNoError )
+			{
+			retCommand = iContactsBufferItemList[iIndex]->iStatus;
+			}
+		else if( iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemAdd )
+			{
+			retCommand = ExecuteAddL();
+			}
+		else if( iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemReplace ||
+iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemFieldLevelReplace )
+			{
+			ExecuteUpdateL();
+			}
+		else if( iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemMove )
+			{
+			ExecuteMoveL();
+			}
+		else if( iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemDelete ||
+				 iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemSoftDelete )
+			{
+			ExecuteDeleteL();
+			}
+		//
+		//	Set allready set commands from iContactsBufferItemList
+		//
+		if( ( iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemAdd     ||
+		      iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemReplace ||
+		      iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemFieldLevelReplace ||
+		      iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemDelete  ||
+		      iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemSoftDelete ) &&
+		      iContactsBufferItemList[iIndex]->iStatus  != KNSmlNoError )
+			{
+			retCommand = iContactsBufferItemList[iIndex]->iStatus;
+			}
+		//if an error occurs when performing any operation
+		//return the error status
+			else if(retCommand!=KErrNone)
+			{
+			User::RequestComplete( iCallerStatus, retCommand );
+			}
+			iRetCommand = retCommand;
+		}
+	}
+// ----------------------------------------------------------------------------
+// void CNSmlContactsDataStore::ExecuteAddL()
+// ----------------------------------------------------------------------------
+EXPORT_C TInt CNSmlContactsDataStore::ExecuteAddL()
+	{
+	TInt  retCommand( KErrNone );
+	StripPropertyL( iItemDataAddBatch, KVersitTokenUID() ); // Remove UID's from data
+	TInt err( KErrNone );
+	if(iBatchMode)
+		{
+		TRAP( err,LdoAddItemsL( iItemDataAddBatch,
+		                   iItemDataAddBatch->Ptr(0).Length()) );
+		if(err!=KErrNone)
+			{
+			retCommand = err;
+			TInt j = iIndex;
+			while( j < iContactsBufferItemList.Count() )
+				{
+				if( iContactsBufferItemList[j]->iModType == ENSmlCntItemAdd &&
+				iContactsBufferItemList[j]->iStatus  == KNSmlNoError )
+					{
+					iContactsBufferItemList[j]->iStatus = KErrNotSupported;
+					iResultArray->AppendL(KErrNotSupported);
+					}
+				j++;
+				}
+			}
+		}
+	else
+		{
+		const TPtr8 dataPtr = iItemDataAddBatch->Ptr(0);
+		TRAP( err, LdoAddItemL( dataPtr,
+					iContactsBufferItemList[iIndex]->iSize));
+		if(err!=KErrNone)
+			{
+			retCommand = err;
+			}
+		}
+	return retCommand;
+	}
+// ----------------------------------------------------------------------------
+// void CNSmlContactsDataStore::ExecuteDeleteL()
+// ----------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore:: ExecuteDeleteL()
+	{
+	if(iBatchMode)
+		{
+		iContactLnks = CVPbkContactLinkArray::NewL();
+		TInt j=iIndex;
+		while( j < iContactsBufferItemList.Count() )
+			{
+			if( (iContactsBufferItemList[j]->iModType == ENSmlCntItemDelete ||
+			iContactsBufferItemList[j]->iModType == ENSmlCntItemSoftDelete) &&
+			iContactsBufferItemList[j]->iStatus  == KNSmlNoError )
+				{
+				TContactItemId id = iContactsBufferItemList[j]->iUid;
+				if( id != 0 )
+					{
+					MVPbkContactLink* contactLink = iIdConverter->IdentifierToLinkLC(id);
+					//check if the contact link is valid
+					TInt index = iContactViewBase->IndexOfLinkL(*contactLink);
+					if(index != KErrNotFound)
+						{
+						iContactLnks->AppendL(contactLink);
+						}
+						else
+						{
+						iContactsBufferItemList[j]->iStatus  = KErrNotFound;
+						}
+					CleanupStack::Pop();//contactLink
+					}
+					else
+					{
+					iContactsBufferItemList[j]->iStatus  = KErrNotFound;
+					}
+				}
+			j++;
+			}
+		delete iContactViewBase;
+		iContactViewBase = NULL;
+		iContactManager->DeleteContactsL( *iContactLnks, *this );
+		iLastOperation = ENSmlDeleteOp;
+		}
+	}
+// ----------------------------------------------------------------------------
+// void CNSmlContactsDataStore::ExecuteUpdateL()
+// ----------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::ExecuteUpdateL()
+	{
+	iUid  = iContactsBufferItemList[iIndex]->iUid;
+	iDataMod->SetUsedMimeType( iServerMimeType, iServerMimeVersion );
+	// Check whether merging is needed or not.
+	if( iDataMod->NeedsMerge() )
+		{
+		iMergeItem = CBufFlat::NewL(64);
+		iWriteStream.Open(*iMergeItem);
+		MVPbkContactLink* contactLink = iIdConverter->IdentifierToLinkLC(iUid);
+		iVCardEngine->ExportVCardForSyncL(iWriteStream,*contactLink,*this);
+		CleanupStack::PopAndDestroy();
+		iLastOperation = ENSMLUpdateExportOp;
+		}
+	else
+		{
+			LdoUpdateItemL();
+		}
+	}
+// ----------------------------------------------------------------------------
+// void CNSmlContactsDataStore::ExecuteMoveL
+// ----------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::ExecuteMoveL()
+	{
+	// move command is not supported
+	if(!iBatchMode)
+		{
+		ResetBuffer();
+		User::RequestComplete( iCallerStatus, KErrNotSupported );
+		}
+	else
+		{
+		iResultArray->AppendL(KErrNotSupported);
+		iIndex++;
+		if(iIndex == iContactsBufferItemList.Count() )
+			{
+			ResetBuffer();
+			User::RequestComplete( iCallerStatus, KErrNone );
+			}
+		else
+			{
+				ExecuteBufferL();
+			}
+		}
+	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoCancelBatch()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoCancelBatch()
 	{
 	if( !iStoreFormat )
 		{
 		TFileName fileName;
 		TParse parse;
-		// Locate the resource file
+		parse.Set( GetStoreFormatResourceFileL(), &KDC_RESOURCE_FILES_DIR, NULL  );
-TFileName dllFileName;
-Dll::FileName( dllFileName );
-TFileName resourceFileName;
-resourceFileName.Copy( TParsePtrC( dllFileName ).Drive() );
-resourceFileName.Append( GetStoreFormatResourceFileL() );
-parse.Set( resourceFileName, &KDC_RESOURCE_FILES_DIR, NULL );
 		fileName = parse.FullName();
-		DBG_ARGS(_S("CNSmlContactsDataStore::SetOwnStoreFormatL(): '%S'"), &parse.FullName());
 		RResourceFile resourceFile;
 		BaflUtils::NearestLanguageFile( iRfs, fileName );
 		resourceFile.OpenL( iRfs, fileName );
 		TResourceReader reader;
 		reader.SetBuffer( contactsDataFormat );
 		iStoreFormat = CSmlDataStoreFormat::NewLC( iStringPool, reader );
-		CleanupStack::Pop(); // iStoreFormat
+		CleanupStack::Pop(iStoreFormat); // iStoreFormat
 		CleanupStack::PopAndDestroy(2); // contactsDataFormat, resourceFile
 		}
 	iDataMod->SetOwnStoreFormat( *iStoreFormat );
 	// Set own MIME type based on store format resource definition. Allows inherited classes to
-	// use non-standard MIME type by recource change. E.g. Operator specific MIME types can be used.
+// use non-standard MIME type by recource change. E.g. Operator specific MIME types can be used.
 iUsedMimeType.Set( iStoreFormat->MimeFormat(0).MimeType().DesC() );
 iUsedMimeVersion.Set( iStoreFormat->MimeFormat(0).MimeVersion().DesC() );
 	_DBG_FILE("CNSmlContactsDataStore::SetOwnStoreFormatL(): end");
 	return;
 	}
 // ----------------------------------------------------------------------------
 		}
 	else
 		{
 		iItemData->Reset();
 		}
-	TInt err = LdoFetchItemL( aUid, *iItemData );
+	 LdoFetchItemL( aUid, *iItemData );
+	 iSize = &aSize;
-	if( !err )
-		{
-		iItemData->Compress();
-		iDataMod->StripTxL( *iItemData );
-//  	Get Item size from database after stripping
-		aSize = iItemData->Size();
-		iState = ENSmlItemOpen;
-		if ( iServerMaxObjectSize == 0 || aSize <= iServerMaxObjectSize )
-			{
-			User::RequestComplete( iCallerStatus, KErrNone );
-			}
-		else
-			{
-			User::RequestComplete( iCallerStatus, KErrTooBig );
-			}
-		}
-	else
-		{
-		User::RequestComplete( iCallerStatus, err );
-		}
 	_DBG_FILE("CNSmlContactsDataStore::DoOpenItemL(): end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoCreateItemL()
 	TInt err = KErrNone;
 	if ( iState != ENSmlOpenAndWaiting )
 		{
-_DBG_FILE("CNSmlContactsDataStore::DoCreateItemL - KErrNotReady: END");
 		User::RequestComplete( iCallerStatus, KErrNotReady );
+		_DBG_FILE("CNSmlContactsDataStore::DoCreateItemL - KErrNotReady: END");
 		return;
 		}
 	iItemSize = aSize; // Size sent from server
 	iModType  = ENSmlCntItemAdd;
 	if( ( aMimeType.MatchF( KNSmlvCard21Name ) < 0 ) &&
 	    ( aMimeType.MatchF( KNSmlvCard30Name ) < 0 ) &&
 	    // Allow using custom MIME type defined in store format resource file
 	    ( aMimeType.MatchF( iUsedMimeType ) < 0 ) )
 		{
-_DBG_FILE("CNSmlContactsDataStore::DoCreateItemL - KErrNotSupported: END");
 		User::RequestComplete( iCallerStatus, KErrNotSupported );
+		_DBG_FILE("CNSmlContactsDataStore::DoCreateItemL - KErrNotSupported: END");
 		return;
 		}
-// Is there enough space on drive ?
+// Is there enough space on drive
 	if( DriveBelowCriticalLevelL( aSize ) )
 		{
 		err = KErrDiskFull;
 		}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoReplaceItemL()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoReplaceItemL( TSmlDbItemUid aUid,
 											 TInt aSize,
 											 TSmlDbItemUid /*aParent*/,
 											 TBool aFieldChange,
 											 TRequestStatus& aStatus )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoReplaceItemL(): begin");
 	TInt err = KErrNone;
 	iUid      = aUid;
 	iItemSize = aSize;
-	iModType  = aFieldChange ? ENSmlCntItemFieldLevelReplace : ENSmlCntItemReplace;
+	iModType  =  aFieldChange ? ENSmlCntItemFieldLevelReplace : ENSmlCntItemReplace;
 	if ( iItemPos == -1 || !iBatchMode )
 		{
 		iItemPos = 0;
 		}
 	if ( iItemData )
 		{
 		iItemData->Reset();
 		}
 	iFieldLevelReplace = aFieldChange;
 	iItemData = AddBufferListL( aUid, aSize, err );
 	if( iBatchMode )
 		{
 		iState = ENSmlItemUpdating;
 		_DBG_FILE("CNSmlContactsDataStore::DoReplaceItemL(): BATCHMODE end");
 		User::RequestComplete( iCallerStatus, KErrNone );
 		return;
 		}
-	CBufBase* tempData = CBufFlat::NewL( KNSmlItemDataExpandSize );
-	CleanupStack::PushL( tempData );
-	_DBG_FILE("CNSmlContactsDataStore::DoReplaceItemL(): CContactDatabase::ExportSelectedContactsL() begin");
-	TInt ret = KErrNone;
-	TRAP( err, ret = ExportContactsL( TUid::Uid(aUid), *tempData ) );
-	_DBG_FILE("CNSmlContactsDataStore::DoReplaceItemL(): CContactDatabase::ExportSelectedContactsL() end");
-	CleanupStack::PopAndDestroy( tempData );
-	if ( err || ret )
-	    {
-	    _DBG_FILE("CNSmlContactsDataStore::DoReplaceItemL(): CContactDatabase::ExportSelectedContactsL() ERROR");
-	    if ( err == KErrNone )
-	        {
-err = ret;
-	        }
-	    User::RequestComplete( iCallerStatus, err );
-		return;
-	    }
-	if( !err && DriveBelowCriticalLevelL( aSize ) ) // Is drive getting full?
-		{
-		err = KErrDiskFull;
-		}
 	if ( err == KErrNone )
 	    {
 	    iState = ENSmlItemUpdating;
 	    }
 // void CNSmlContactsDataStore::DoReadItemL()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoReadItemL( TDes8& aBuffer )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoReadItemL(): begin");
 if ( iState != ENSmlItemOpen || !iItemData )
 {
 iItemPos = -1;
 User::Leave( KErrNotReady );
 }
 }
 else
 {
 iItemData->Read( iItemPos, aBuffer, iItemData->Size() - iItemPos );
 iItemPos = -1;
 }
 	_DBG_FILE("CNSmlContactsDataStore::DoReadItemL(): end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoWriteItemL()
 	    {
 iContactsBufferItemList[iContactsBufferItemList.Count()-1]->iStatus  = KNSmlNoError;
 	    }
 	    }
 	 else if ((iModType   == ENSmlCntItemAdd ||         // If some write problems
-	       iModType   == ENSmlCntItemReplace ||
+iModType   == ENSmlCntItemReplace ||
-	       iModType   == ENSmlCntItemFieldLevelReplace ) &&
+iModType   == ENSmlCntItemFieldLevelReplace ) &&
-	       iStateItem != KErrNone &&
+	 iStateItem != KErrNone &&
-	       iContactsBufferItemList.Count() > 0)
+	 iContactsBufferItemList.Count() > 0)
 	    {
 iContactsBufferItemList[iContactsBufferItemList.Count()-1]->iStatus  = iStateItem;
 	    }
 	if( iBatchMode )
 		{
 		iItemData = NULL;
 		iState = ENSmlOpenAndWaiting;
 		User::RequestComplete( iCallerStatus, KErrNone );
 		return;
 		}
-	RArray<TInt> noResultArray;
-	CleanupClosePushL( noResultArray );
+	iIndex = 0;
+	ExecuteBufferL();
-	TRAPD(err, ExecuteBufferL( noResultArray ));
-	if( noResultArray.Count() == 1 )	// Should be a single item commit
-		{
-		err = noResultArray[0];
-		}
-	CleanupStack::PopAndDestroy(); // noResultArray
-	//
-	// Empty Buffer if not batch mode
-	//
-	if ( !iBatchMode )
-		{
-		if(iItemData)
-		    {
-		    iItemData->Reset();
-		    }
-		if(iItemDataAddBatch)
-		    {
-		    iItemDataAddBatch->Reset();
-		    }
-		iContactsBufferItemList.ResetAndDestroy();
-		}
 	iItemData = NULL;
 	iState = ENSmlOpenAndWaiting;
-	User::RequestComplete( iCallerStatus, err );
 	_DBG_FILE("CNSmlContactsDataStore::DoCommitItemL(): end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoDeleteItemL()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoDeleteItemL( TSmlDbItemUid aUid, TRequestStatus& aStatus )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoDeleteItemL(): begin");
-	TInt err = KErrNone;
 	iCallerStatus = &aStatus;
 	*iCallerStatus = KRequestPending;
 	if( iBatchMode )
 		{
-		if( iModType != ENSmlCntItemSoftDelete ) // Treated like deletes
+		if(iContactViewBase ==NULL)
-			{
+		{
-			iModType  = ENSmlCntItemDelete;
+		CreateViewL();
-			}
+		}
+	if( iModType != ENSmlCntItemSoftDelete ) // Treated like deletes
+		{
+		iModType  = ENSmlCntItemDelete;
+		}
-		TInt fSize = 0;
+	TInt fSize = 0;
-		AddBufferListL( aUid, fSize, KErrNone );
+	AddBufferListL( aUid, fSize, KErrNone );
-		User::RequestComplete( iCallerStatus, KErrNone );
+	User::RequestComplete( iCallerStatus, KErrNone );
-		return;
+	return;
-		}
+	}
+	iUid = aUid;
-	if( iContactsDataStoreExtension->DeleteContactL( TUid::Uid(aUid) ) )
-		{
+	//add the contactlink to CVPbkContactLinkArray
-iChangeFinder->ItemDeleted( TNSmlSnapshotItem( aUid ) );
+	MVPbkContactLink* contactLink  = iIdConverter->IdentifierToLinkLC(aUid);
-		}
+	CleanupStack::Pop();
-	else
+	CVPbkContactLinkArray* contactLnks = CVPbkContactLinkArray::NewLC();
-	    {
+	contactLnks->AppendL( contactLink );
-err = KErrGeneral;
-	    }
+	iContactManager->DeleteContactsL( *contactLnks, *this );
+	CleanupStack::PopAndDestroy();
-	User::RequestComplete( iCallerStatus, err );
+	iLastOperation = ENSmlDeleteOp;
 	_DBG_FILE("CNSmlContactsDataStore::DoDeleteItemL(): end");
 	}
 // ----------------------------------------------------------------------------
 // void CNSmlContactsDataStore::DoDeleteAllItemsL()
 // ----------------------------------------------------------------------------
 EXPORT_C void CNSmlContactsDataStore::DoDeleteAllItemsL( TRequestStatus& aStatus )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoDeleteAllItemsL(): begin");
 	iCallerStatus = &aStatus;
 	*iCallerStatus = KRequestPending;
-	if( iContactsDataStoreExtension->DeleteAllContactsL() )
+	//create view to get all the contactlinks to delete
-	    {
+	if(iContactViewBase ==NULL)
-if( iChangeFinder )
+		{
-{
+		CreateViewL();
-iChangeFinder->ResetL();
+		}
-}
-iSnapshotRegistered = EFalse;
+	iLastOperation = ENSMLDeleteAllOp;
-User::RequestComplete( iCallerStatus, KErrNone );
-	    }
-	else
-	    {
-DBG_ARGS(_S("CNSmlContactsDataStore::DoDeleteAllItemsL(): Error"));
-User::RequestComplete( iCallerStatus, KErrGeneral );
-	    }
 	_DBG_FILE("CNSmlContactsDataStore::DoDeleteAllItemsL(): end");
 	}
 // ----------------------------------------------------------------------------
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoResetChangeInfoL(): begin");
 	iCallerStatus = &aStatus;
 	*iCallerStatus = KRequestPending;
+	if( iChangeFinder )
+		{
+		iChangeFinder->ResetL();
+		}
 	iSnapshotRegistered = EFalse;
-	if( iChangeFinder )
+		if ( iContactsModsFetcher )
 		{
-		iChangeFinder->ResetL();
+		iContactsModsFetcher->FetchModificationsL( aStatus );
-		FetchModificationsL();
+#ifdef __NSML_MODULETEST__
-		}
+		CActiveScheduler::Start();
+#endif
-User::RequestComplete( iCallerStatus, KErrNone );
+		}
+	else
+		{
+		User::RequestComplete( iCallerStatus, KErrNone );
+		}
 	_DBG_FILE("CNSmlContactsDataStore::DoResetChangeInfoL(): end");
 	}
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 EXPORT_C CDesCArray* CNSmlContactsDataStore::DoListStoresLC()
 	{
 	_DBG_FILE("CNSmlContactsDataStore::DoListStoresLC(): begin");
-	 /*CDesCArray* cntStores = new (ELeave) CDesCArrayFlat(1);
+	MVPbkContactStoreList& storeList = iContactManager->ContactStoresL();
-	 iContactsDataStoreExtension->ListStoresL( cntStores );
+	CDesCArrayFlat* stores = new (ELeave) CDesCArrayFlat(storeList.Count());
-CleanupStack::PushL( cntStores );*/
+	CleanupStack::PushL( stores );
-	 CDesCArray* array = new (ELeave) CDesCArrayFlat(1);
+TBuf<KVPbhkPrefixLength> phoneDataBasePrefix(KVPbhkSymbianDBPrefix);
-	 array->AppendL(*iDefaultStoreName);
-	 CleanupStack::PushL( array );
+	for(TInt i=0 ; i< storeList.Count(); i++)
+	{
-_DBG_FILE("CNSmlContactsDataStore::DoListStoresLC(): end");
+	    TBuf<KNSmlDefaultStoreNameMaxSize>  currentStore(storeList.At(i).StoreProperties().Uri().UriDes());
-return array;
+	    if(currentStore.Find(phoneDataBasePrefix) == 0)//Check if Symbian Database
+	    {
+	    		//For backward compatability with local and remote servers
+	    //The Symbian Db name remains unchanged
+	    //The engine methods that create syncml packet, use this information in Database fields
+	            stores->AppendL(*iPacketStoreName);
+	    }
+	    else//End Symbian Database check
+	    {
+		     stores->AppendL(storeList.At(i).StoreProperties().Uri().UriDes());
+	    }
+	}
+	_DBG_FILE("CNSmlContactsDataStore::DoListStoresLC(): end");
+	return stores;
 	}
 // ------------------------------------------------------------------------------------------------
 // TInt CNSmlContactsDataStore::LdoFetchItemL( TSmlDbItemUid& aUid, CBufBase& aItem )
 // ------------------------------------------------------------------------------------------------
-EXPORT_C TInt CNSmlContactsDataStore::LdoFetchItemL( TSmlDbItemUid& aUid, CBufBase& aItem )
+EXPORT_C void CNSmlContactsDataStore::LdoFetchItemL( TSmlDbItemUid& aUid, CBufBase& aItem )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::LdoFetchItemL(): begin");
-	_DBG_FILE("CNSmlContactsDataStore::FetchItemL(): CContactDatabase::ExportSelectedContactsL() begin");
+	 iWriteStream.Open(aItem);
-	TInt err = KErrNone;
+	 MVPbkContactLink* contactLink  = iIdConverter->IdentifierToLinkLC(aUid);
-	TInt ret = KErrNone;
+	 iVCardEngine->ExportVCardForSyncL(iWriteStream,*contactLink,*this);
+	 CleanupStack::PopAndDestroy();
-	TRAP( err, ret = ExportContactsL( TUid::Uid(aUid), aItem ) );
+	 iLastOperation = ENSMLFetchOp;
-	if( ret != KErrNone )
-	    {
-DBG_ARGS(_S("CNSmlContactsDataStore::FetchItemL(): Error = %d"), ret);
-err = ret;
-	    }
-	_DBG_FILE("CNSmlContactsDataStore::FetchItemL(): CContactDatabase::ExportSelectedContactsL() end");
 	_DBG_FILE("CNSmlContactsDataStore::LdoFetchItemL(): end");
-	return err;
 	}
 // ------------------------------------------------------------------------------------------------
 // TInt CNSmlContactsDataStore::LdoAddItemL( TSmlDbItemUid& aUid,
 //                                           const TDesC8& aItem,
 //                                           TInt aSize,
-//                                           TTime& aLastModified )
+//                                           TTime& aLastModified,
+//                                           TBool& aConfidential )
 // ------------------------------------------------------------------------------------------------
-EXPORT_C TInt CNSmlContactsDataStore::LdoAddItemL( TSmlDbItemUid& aUid,
+EXPORT_C void CNSmlContactsDataStore::LdoAddItemL( const TDesC8& aItem,
-const TDesC8& aItem,
+TInt aSize)
-TInt aSize,
-TTime& aLastModified )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::LdoAddItemL(): begin");
-	TInt ret( KErrNone );
 	if( !iOpened )
 		{
 		User::Leave( KErrNotReady );
 		}
-	// Is there enough space on drive ?
+	// Is there enough space on drive
 	if( DriveBelowCriticalLevelL( aSize ) )
 		{
-		return KErrDiskFull;
+		User::Leave( KErrDiskFull );
 		}
-	HBufC8* buf = aItem.AllocLC();
+	 iBuf = aItem.AllocLC();
-	StripPropertyL( buf, KVersitTokenUID() );
+	StripPropertyL( iBuf, KVersitTokenUID() );
-	CArrayFixFlat<TUid>* entryArray = NULL;
+	 iReadStream.Open( *iBuf );
-	TRAP( ret, entryArray = ImportContactsL( *buf ) );
+	// import a vcard without checking for duplicates
+	iVCardEngine->ImportVCardForSyncL(*iStore,iReadStream,*this);
-DBG_ARGS(_S("New item to database with return value: '%d'"), ret );
+	iLastOperation = ENSmlAddOp;
+	CleanupStack::Pop(iBuf);
-	if( ret == KErrNone && entryArray != NULL )
-		{
-		CleanupStack::PushL( entryArray );
-		if( entryArray->Count() )
-			{
-TInt err(KErrNone);
-			TUid tId = entryArray->At( 0 );
-			CNsmlContactItem* contactitem = CNsmlContactItem::NewL();
-			CleanupStack::PushL( contactitem );
-			err = iContactsDataStoreExtension->ReadContactL( tId, contactitem );
-			if( err == KErrNone)
-			    {
-aLastModified = contactitem->iLastModified;
-aUid = tId.iUid;
-			    }
-			CleanupStack::PopAndDestroy( contactitem );
-			}
-		else
-			{
-			ret = KErrNotSupported;
-			}
-		CleanupStack::PopAndDestroy( entryArray );
-		CleanupStack::PopAndDestroy( buf );
-		}
-	else
-		{
-		ret = KErrNotSupported;
-CleanupStack::PopAndDestroy( buf );
-		}
 	_DBG_FILE("CNSmlContactsDataStore::LdoAddItemL(): end");
-	return ret;
 	}
 // ------------------------------------------------------------------------------------------------
-// TInt CNSmlContactsDataStore::LdoAddItemsL( RArray<TInt>& aUids,CBufBase*& aItems,
+// TInt CNSmlContactsDataStore::LdoAddItemsL( CBufBase*& aItems,
-//                                            TInt aSize, TTime& aLastModified )
+//                                           TInt aSize)
 // ------------------------------------------------------------------------------------------------
-EXPORT_C TInt CNSmlContactsDataStore::LdoAddItemsL( RArray<TInt>& aUids,
+EXPORT_C void CNSmlContactsDataStore::LdoAddItemsL( CBufBase*& aItems,
-CBufBase*& aItems,
+TInt aSize)
-TInt aSize,
+	{
-TTime& aLastModified  )
+	_DBG_FILE("CNSmlContactsDataStore::LdoAddItemL(): begin");
-	{
-	_DBG_FILE("CNSmlContactsDataStore::LdoAddItemsL(): begin");
-	TInt ret( KErrNone );
 	if( !iOpened )
 		{
 		User::Leave( KErrNotReady );
 		}
-	// Is there enough space on drive ?
+	// Is there enough space on drive
 	if( DriveBelowCriticalLevelL( aSize ) )
 		{
-		return KErrDiskFull;
+		User::Leave( KErrDiskFull );
 		}
-	CArrayFixFlat<TUid>* entryArray = NULL;
+	iReadStream.Open( aItems->Ptr(0) );
-TRAP( ret, entryArray = ImportContactsL( aItems->Ptr( 0 ) ) );
+	 // import vcards without checking for duplicates
+	iVCardEngine->ImportVCardForSyncL(*iStore,iReadStream,*this);
-DBG_ARGS(_S("New items to database with return value: '%d'"), ret );
+	iLastOperation = ENSmlAddOp;
+	_DBG_FILE("CNSmlContactsDataStore::LdoAddItemL(): end");
-	if( ret == KErrNone && entryArray != NULL)
-		{
+	}
-		CleanupStack::PushL( entryArray );
-		if( entryArray->Count() )
-			{
-			TInt i = 0;
-			while( i < entryArray->Count() )
-				{
-				TUid tId = entryArray->At(i);
-				if (i == (entryArray->Count()-1) ) // Get last Modified date
-					{
-TInt err(KErrNone);
-CNsmlContactItem* contactitem = CNsmlContactItem::NewL();
-CleanupStack::PushL( contactitem );
-err = iContactsDataStoreExtension->ReadContactL( tId, contactitem );
-				    if( err == KErrNone )
-{
-aLastModified = contactitem->iLastModified;
-}
-					CleanupStack::PopAndDestroy( contactitem );
-					}
-				aUids.Append( tId.iUid );
-				i++;
-				}
-			}
-		else
-			{
-			ret = KErrNotSupported;
-			}
-		CleanupStack::PopAndDestroy( entryArray );
-		}
-	else
-		{
-	    ret = KErrNotSupported;
-		}
-	_DBG_FILE("CNSmlContactsDataStore::LdoAddItemsL(): end");
-	return ret;
-	}
 // ------------------------------------------------------------------------------------------------
 // TInt CNSmlContactsDataStore::LdoUpdateItemL(TSmlDbItemUid aUid,
 //                                             const TDesC8& aItem,
 //                                             TInt aSize,
 //                                             TTime& aLastModified )
 // ------------------------------------------------------------------------------------------------
-EXPORT_C TInt CNSmlContactsDataStore::LdoUpdateItemL( TSmlDbItemUid aUid,
+EXPORT_C void CNSmlContactsDataStore::LdoUpdateItemL()
-const TDesC8& aItem,
-TInt aSize,
-TTime& aLastModified )
 	{
 	_DBG_FILE("CNSmlContactsDataStore::LdoUpdateItemL(): begin");
-	TInt ret(KErrNone);
+	iBuf = iContactsBufferItemList[iIndex]->iItemData->Ptr(0).AllocLC();
-	// Is there enough space on drive ?
+	// Remove UID's from data
-	if( DriveBelowCriticalLevelL( aSize) )
+	StripPropertyL( iBuf, KVersitTokenUID() );
-		{
-		return KErrDiskFull;
+	iReadStream.Open( *iBuf );
-		}
+	iContactLink = iIdConverter->IdentifierToLinkLC(iUid);
+	iVCardEngine->ImportVCardMergeL(*iContactLink, *iStore, iReadStream, *this);
-	CNsmlContactItem* contactitem = CNsmlContactItem::NewL();
-	CleanupStack::PushL( contactitem );
+	CleanupStack::Pop();
-ret = iContactsDataStoreExtension->ReadContactL( TUid::Uid( aUid ), contactitem );
+	iLastOperation = ENSMLUpdateImportOp;
+	CleanupStack::Pop(iBuf);
-if( ret != KErrNone )
-{
-CleanupStack::PopAndDestroy( contactitem );
-DBG_ARGS(_S("CNSmlContactsDataStore::LdoUpdateItemL(): Error = %d"), ret);
-return ret;
-}
-// Set mimetype + version
-	iDataMod->SetUsedMimeType( iServerMimeType, iServerMimeVersion );
-	DBG_DUMP((void*)aItem.Ptr(), aItem.Length(),
-	        _S8("CNSmlContactsDataStore::LdoUpdateItemL(): ReceivedItem:"));
-	CBufBase* bItem = LdoMergeLC( aUid, aItem );
-	HBufC8* hItemBuf = HBufC8::NewL( bItem->Size() + 80 );
-	*hItemBuf = bItem->Ptr(0);
-	CleanupStack::PopAndDestroy(); // bItem
-	CleanupStack::PushL( hItemBuf );
-	StripPropertyL( hItemBuf, KVersitTokenUID() );
-	TPtr8 hItemPtr( hItemBuf->Des() );
-	HBufC8* endPropBuf = HBufC8::NewLC( KVersitTokenEND().Length() + KVersitTokenCRLF().Length() + KVersitTokenColon().Length() );
-	TPtr8 endPropPtr( endPropBuf->Des() );
-	endPropPtr.Append( KVersitTokenCRLF() );
-	endPropPtr.Append( KVersitTokenEND() );
-	endPropPtr.Append( KVersitTokenColon() );
-	TInt endPos = hItemPtr.Find( endPropPtr );
-	if( endPos == KErrNotFound )
-		{
-		User::Leave( KErrNotSupported );
-		}
-	hItemPtr.Insert( endPos, KVersitTokenCRLF() );
-	endPos += KVersitTokenCRLF().Length();
-	hItemPtr.Insert( endPos, KVersitTokenUID() );
-	endPos += KVersitTokenUID().Length();
-	hItemPtr.Insert( endPos, KVersitTokenColon() );
-	endPos += KVersitTokenColon().Length();
-	hItemPtr.Insert( endPos, *contactitem->iGuid );
-	DBG_DUMP((void*)hItemPtr.Ptr(), hItemPtr.Length(),
-	            _S8("CNSmlContactsDataStore::LdoUpdateItemL(): MergedItem:"));
-	CleanupStack::PopAndDestroy( endPropBuf );
-	// TODO: Get it reviewed
-	CArrayFixFlat<TUid>* entryArray = NULL;
-TRAP( ret, entryArray = ImportContactsL( hItemPtr ) );
-if( ret == KErrNone && entryArray != NULL)
-		{
-CleanupStack::PushL( entryArray );
-		if( !entryArray->Count() )
-			{
-			ret = KErrNotSupported;
-			}
-		else
-			{
-TInt err(KErrNone);
-			TUid tId = TUid::Uid( aUid );
-			CNsmlContactItem* updatedContactitem = CNsmlContactItem::NewL();
-			CleanupStack::PushL( updatedContactitem );
-			err = iContactsDataStoreExtension->ReadContactL( tId, contactitem );
-if( err == KErrNone)
-{
-aLastModified = updatedContactitem->iLastModified;
-}
-			CleanupStack::PopAndDestroy( updatedContactitem ); // updatedContact
-			}
-		CleanupStack::PopAndDestroy(3); // contactitem,  hItemBuf, entryArray
-		}
-	else
-		{
-		ret = KErrNotSupported;
-		CleanupStack::PopAndDestroy(2); // contactitem,  hItemBuf
-		}
-	iFieldLevelReplace = EFalse;
 	_DBG_FILE("CNSmlContactsDataStore::LdoUpdateItemL(): end");
-	return ret;
 	}
-// ------------------------------------------------------------------------------------------------
-//  CBufBase* CNSmlContactsDataStore::LdoMergeLC( TSmlDbItemUid& aUid, const TDesC8& aItem )
-// ------------------------------------------------------------------------------------------------
-EXPORT_C CBufBase* CNSmlContactsDataStore::LdoMergeLC( TSmlDbItemUid& aUid, const TDesC8& aItem )
-	{
-	_DBG_FILE("CNSmlContactsDataStore::LdoMergeLC(): begin");
-	CBufFlat* b = CBufFlat::NewL(64);
-	CleanupStack::PushL( b );
-	b->InsertL( 0, aItem );
-	if( iDataMod->NeedsMerge() )
-		{
-		CBufFlat* mergeItem = CBufFlat::NewL(64);
-		CleanupStack::PushL( mergeItem );
-		if( LdoFetchItemL( aUid, *mergeItem) == KErrNone )
-			{
-iDataMod->MergeRxL( *b, *mergeItem, iFieldLevelReplace );
-			}
-		CleanupStack::PopAndDestroy(); // mergeItem
-		}
-	_DBG_FILE("CNSmlContactsDataStore::LdoMergeLC(): end");
-	return b;
-	}
 // ------------------------------------------------------------------------------------------------
 // CNSmlContactsDataStore::DriveBelowCriticalLevelL()
 // ------------------------------------------------------------------------------------------------
 EXPORT_C TBool CNSmlContactsDataStore::DriveBelowCriticalLevelL( TInt aSize )
 	iContactsBufferItemList.AppendL( newBufferItem );
 	iMimeTypeItem.Set( KNullDesC8 );
 	iMimeVersionItem.Set( KNullDesC8 );
-	iLastItem = ETrue;
 	CleanupStack::Pop();
 	if( iModType == ENSmlCntItemAdd &&
 	    aStatus  == KErrNotSupported )
 		_DBG_FILE("CNSmlContactsDataStore::StripPropertyL(): property removed");
 		}
 	CleanupStack::PopAndDestroy(); // propBuf
 	_DBG_FILE("CNSmlContactsDataStore::StripPropertyL(): end");
 	}
+// ----------------------------------------------------------------------------
+// CNSmlContactsDataStore::IsConfidentialL
+// ----------------------------------------------------------------------------
+//
+EXPORT_C TBool CNSmlContactsDataStore::IsConfidentialL(  MVPbkStoreContact& aItem )
+{
+_DBG_FILE("CNSmlContactsDataStore::IsConfidentialL(): begin");
+TBool ret( EFalse );
+//find X-CLASS field type
+	const MVPbkFieldType* syncclass =
+iContactManager->FieldTypes().Find(R_VPBK_FIELD_TYPE_SYNCCLASS );
+	CVPbkBaseContactFieldTypeIterator* itr =
+CVPbkBaseContactFieldTypeIterator::NewLC( *syncclass,
+aItem.Fields() );
+	while ( itr->HasNext() )
+{
+const MVPbkBaseContactField* field = itr->Next();
+const MVPbkContactFieldTextData& data = MVPbkContactFieldTextData::Cast(field->FieldData());
+TPtrC ptr = data.Text();
+//compare the sync type
+if ( ptr.Compare( KNSmlContactSyncNoSync ) == 0 )
+{
+_DBG_FILE("CNSmlContactsDataStore::IsConfidentialL(): \
+find confidential");
+ret = ETrue;
+}
+}
+	CleanupStack::PopAndDestroy( itr );
+_DBG_FILE("CNSmlContactsDataStore::IsConfidentialL(): end");
+return ret;
+}
+// ----------------------------------------------------------------------------
+// CNSmlContactsDataStore::ResetBuffer
+// ----------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore:: ResetBuffer()
+	{
+	if( iItemDataAddBatch )
+		{
+		iItemDataAddBatch->Reset();
+		}
+	iContactsBufferItemList.ResetAndDestroy();
+	}
+// -----------------------------------------------------------------------------
+// From MVPbkContactStoreListObserver
+// Called when a contact store is ready to use.
+// -----------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::StoreReady( MVPbkContactStore& /*aContactStore*/ )
+	{
+	_DBG_FILE("CNSmlContactsDataStore::StoreReady(): begin");
+	//The contact data base opened successfully
+	iOpened = ETrue;
+	//id to uniquely identify the opened store
+	iOpenedStoreId = DefaultHash::Des16(
+						iStore->StoreProperties().Uri().UriDes());
+	TRAPD(error, iContactsModsFetcher->FetchModificationsL( *iCallerStatus ));
+	if(error != KErrNone)
+		{
+		User::RequestComplete( iCallerStatus, error );
+		}
+	_DBG_FILE("CNSmlContactsDataStore::StoreReady(): end");
+	}
+// ---------------------------------------------------------------------------
+//  From MVPbkContactStoreListObserver
+//	Called when a contact store becomes unavailable.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::StoreUnavailable(
+MVPbkContactStore& /*aContactStore*/,
+TInt aReason )
+{
+_DBG_FILE("CNSmlContactsDataStore::StoreUnavailable(): begin");
+//Unable open the default contact data base
+	iOpened = EFalse;
+	delete iStoreName;
+	iStoreName = NULL;
+	iOpenedStoreId = 0;
+	User::RequestComplete( iCallerStatus, aReason );
+	_DBG_FILE("CNSmlContactsDataStore::StoreUnavailable(): end");
+	return;
+}
+// ---------------------------------------------------------------------------
+// From MVPbkContactStoreListObserver
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::HandleStoreEventL(
+MVPbkContactStore& /*aContactStore*/,
+TVPbkContactStoreEvent /*aStoreEvent*/ )
+	{
+	//Indication not needed.
+	}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::VPbkSingleContactOperationComplete
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::VPbkSingleContactOperationComplete(
+		MVPbkContactOperationBase& aOperation,
+		MVPbkStoreContact* aContact )
+	{
+	MVPbkContactOperationBase* operation = &aOperation;
+	if ( operation )
+	{
+		delete operation;
+		operation = NULL;
+	}
+	TRAPD(error ,SingleContactOperationCompleteL(aContact));
+	delete aContact;
+	if(error!= KErrNone)
+		{
+			User::RequestComplete( iCallerStatus, error );
+		}
+	}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::VPbkSingleContactOperationFailed
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::VPbkSingleContactOperationFailed(
+MVPbkContactOperationBase& aOperation,
+TInt aError )
+{
+	MVPbkContactOperationBase* operation = &aOperation;
+	if ( operation )
+	    {
+		delete operation;
+		operation = NULL;
+	    }
+	 if(iLastOperation == ENSMLFetchOp)
+		{
+	 	iWriteStream.Close();
+	 	User::RequestComplete( iCallerStatus, aError );
+	 	}
+	else if (iLastOperation == ENSMLUpdateExportOp)
+{
+iWriteStream.Close();
+delete iMergeItem;
+iMergeItem = NULL;
+User::RequestComplete( iCallerStatus, aError );
+}
+	else if (iLastOperation == ENSMLUpdateImportOp)
+{
+if(iBatchMode)
+{
+iResultArray->Append( aError );
+}
+		delete iContactLink;
+iContactLink = NULL;
+delete iBuf;
+iBuf = NULL;
+iReadStream.Close();
+iIndex++;
+if(iIndex == iContactsBufferItemList.Count() )
+{
+ResetBuffer();
+User::RequestComplete( iCallerStatus, aError );
+}
+else
+{
+_DBG_FILE("VPbkSingleContactOperationFailed, Continuing to complete the Batch Operation");
+ExecuteBufferL();
+}
+}
+	else if(iLastOperation == ENSmlRetrieveOp)
+	    {
+iRetrieveCount--;
+if(iBatchMode)
+{
+iResultArray->AppendL( aError );
+}
+iIndex++;
+if(iIndex == iContactsBufferItemList.Count() )
+{
+ResetBuffer();
+User::RequestComplete( iCallerStatus, aError );
+}
+else if(!iRetrieveCount)
+{
+_DBG_FILE("VPbkSingleContactOperationFailed, Continuing to complete the Batch Operation");
+ExecuteBufferL();
+}
+	    }
+else
+{
+_DBG_FILE("VPbkSingleContactOperationFailed, No Matching LastOperation Completing the Operation");
+User::RequestComplete( iCallerStatus, aError );
+}
+	_DBG_FILE("CNSmlContactsDataStore::VPbkSingleContactOperationFailed(): end");
+	}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::VPbkSingleContactOperationFailed
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::SingleContactOperationCompleteL(
+		MVPbkStoreContact* aContact)
+	{
+	if(iLastOperation == ENSMLFetchOp)
+		{
+		iWriteStream.Close();
+		iItemData->Compress();
+		//strip the fields not supported by server
+		iDataMod->StripTxL( *iItemData );
+		*iSize = iItemData->Size();
+		iState = ENSmlItemOpen;
+		if ( iServerMaxObjectSize == 0 || *iSize <= iServerMaxObjectSize )
+			{
+			User::RequestComplete( iCallerStatus, KErrNone );
+			}
+		else
+			{
+			User::RequestComplete( iCallerStatus, KErrTooBig );
+			}
+		}
+	else if (iLastOperation == ENSMLUpdateExportOp)
+		{
+		iDataMod->MergeRxL( *iContactsBufferItemList[iIndex]->iItemData,
+		    *iMergeItem, iFieldLevelReplace );
+		iWriteStream.Close();
+		delete iMergeItem;
+		iMergeItem = NULL;
+		LdoUpdateItemL();
+		}
+	else if (iLastOperation == ENSMLUpdateImportOp)
+		{
+		iFieldLevelReplace = EFalse;
+		if(!IsConfidentialL(*aContact))
+			{
+			TInt32 id = iIdConverter->LinkToIdentifier(*aContact->CreateLinkLC());
+			TNSmlSnapshotItem item(id);
+			MVPbkStoreContact2* tempContact =
+					reinterpret_cast<MVPbkStoreContact2*> (aContact->StoreContactExtension (KMVPbkStoreContactExtension2Uid));
+			MVPbkStoreContactProperties *contactProterties
+										= tempContact ->PropertiesL();;
+			CleanupDeletePushL(contactProterties);
+			item.SetLastChangedDate(contactProterties->LastModifiedL());
+			CleanupStack::PopAndDestroy();
+			item.SetSoftDelete( EFalse );
+			TRAP_IGNORE(iChangeFinder->ItemUpdatedL( item ));
+			CleanupStack::PopAndDestroy();
+			if(iBatchMode)
+				{
+				iResultArray->Append(KErrNone);
+				}
+	        delete iContactLink;
+	        iContactLink = NULL;
+			delete iBuf;
+			iBuf = NULL;
+			iReadStream.Close();
+			iIndex++;
+			if(iIndex == iContactsBufferItemList.Count() )
+				{
+				ResetBuffer();
+				User::RequestComplete( iCallerStatus, iRetCommand );
+				}
+			else
+				{
+					ExecuteBufferL();
+				}
+			}
+		}
+	else if(iLastOperation == ENSmlRetrieveOp)
+		{
+		iRetrieveCount--;
+		if(!IsConfidentialL(*aContact))
+			{
+			TInt32 id = iIdConverter->LinkToIdentifier(*aContact->CreateLinkLC());
+			*iContactsBufferItemList[iIndex]->iPUid = id;
+			TNSmlSnapshotItem item(id);
+		MVPbkStoreContact2* tempContact =
+		    reinterpret_cast<MVPbkStoreContact2*> (aContact->StoreContactExtension (KMVPbkStoreContactExtension2Uid));
+			MVPbkStoreContactProperties *contactProterties
+										= tempContact ->PropertiesL();;
+			CleanupDeletePushL(contactProterties);
+			item.SetLastChangedDate(contactProterties->LastModifiedL());
+			CleanupStack::PopAndDestroy();
+			item.SetSoftDelete( EFalse );
+			// Add the snapshot item to the Change Finder.
+			TRAP_IGNORE(iChangeFinder->ItemAddedL( item ));
+			CleanupStack::PopAndDestroy();
+			}
+			if(iBatchMode)
+			{
+			iResultArray->AppendL(iRetCommand);
+			}
+			iIndex++;
+			if(iIndex == iContactsBufferItemList.Count() )
+				{
+				ResetBuffer();
+				User::RequestComplete( iCallerStatus, iRetCommand );
+				}
+			else if(!iRetrieveCount)
+				{
+					ExecuteBufferL();
+				}
+			}
+}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::ContactsSaved.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::ContactsSaved(
+		MVPbkContactOperationBase& aOperation,
+MVPbkContactLinkArray* aResults )
+	{
+	MVPbkContactOperationBase* operation = &aOperation;
+	if ( operation )
+	{
+		delete operation;
+		operation = NULL;
+	}
+	if(iLastOperation == ENSmlAddOp)
+		{
+		//Count of contacts to be added from server to client
+		TInt  cntAddCount( 0 );
+		TInt i(iIndex);
+		while( i<iContactsBufferItemList.Count() )
+			{
+			if ( iContactsBufferItemList[i]->iModType == ENSmlCntItemAdd &&
+			     iContactsBufferItemList[i]->iStatus  == KNSmlNoError )
+				{
+				cntAddCount++;
+				}
+			i++;
+			}
+		//Count of contacts successfully added to client
+		iRetrieveCount = aResults->Count();
+		//Count of contacts which could not be added
+		TInt cntAddFailedCount(0);
+		cntAddFailedCount = cntAddCount-iRetrieveCount;
+		while(cntAddFailedCount > 0)
+		{
+			iContactsBufferItemList[iIndex++]->iStatus  = KErrGeneral;
+			iResultArray->Append(KErrGeneral);
+			cntAddFailedCount--;
+		}
+		if ( aResults->Count() > 0 )
+			{
+			for(TInt i=0;i<aResults->Count();i++)
+				{
+				//retrieve the contact
+				TRAPD(error,iContactManager->RetrieveContactL( aResults->At(i), *this ));
+				if(error != KErrNone)
+					{
+					User::RequestComplete( iCallerStatus, error );
+					}
+			iLastOperation = ENSmlRetrieveOp;
+				}
+			}
+		delete iBuf;
+		delete aResults;
+		iBuf = NULL;
+		iReadStream.Close();
+		}
+	}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::ContactsSavingFailed
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::ContactsSavingFailed(
+MVPbkContactOperationBase& aOperation, TInt aError )
+	{
+	MVPbkContactOperationBase* operation = &aOperation;
+	if ( operation )
+	{
+		delete operation;
+		operation = NULL;
+	}
+	if(iLastOperation == ENSmlAddOp)
+	{
+	if(iBatchMode)
+		{
+		while( iIndex < iContactsBufferItemList.Count() &&
+		iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemAdd )
+			{
+			iContactsBufferItemList[iIndex++]->iStatus  = KErrGeneral;
+			iResultArray->Append(KErrGeneral);
+			}
+		}
+	else
+		{
+		iIndex++;
+		}
+	if(iIndex == iContactsBufferItemList.Count())
+		{
+		User::RequestComplete( iCallerStatus, aError );
+		ResetBuffer();
+		delete iBuf;
+	 	iBuf = NULL;
+	 	iReadStream.Close();
+		}
+		//Execute the remaining commands in batch
+		else
+		{
+			TRAPD(error,ExecuteBufferL());
+			if(error != KErrNone)
+			{
+			User::RequestComplete( iCallerStatus, error );
+			}
+		}
+		}
+	}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::StepComplete
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::StepComplete(
+		 MVPbkContactOperationBase& /*aOperation*/,
+TInt aStepSize )
+	{
+	if(iLastOperation == ENSmlDeleteOp)
+		{
+		if(iBatchMode)
+			{
+			for(TInt i = 0 ; i<aStepSize && iIndex < iContactsBufferItemList.Count() ;i++)
+				{
+				iResultArray->Append(KErrNone);
+				if( iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemDelete &&
+			    iContactsBufferItemList[iIndex]->iStatus  == KNSmlNoError )
+					{
+					iContactsBufferItemList[iIndex]->iStatus  = KErrNone;
+					iUid  = iContactsBufferItemList[iIndex]->iUid;
+					iChangeFinder->ItemDeleted( TNSmlSnapshotItem( iUid ));
+					}
+					else if( iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemSoftDelete &&
+				   		 iContactsBufferItemList[iIndex]->iStatus  == KNSmlNoError )
+					{
+					iContactsBufferItemList[iIndex]->iStatus  = KErrNone;
+					iUid  = iContactsBufferItemList[iIndex]->iUid;
+					TRAP_IGNORE(iChangeFinder->ItemSoftDeletedL( TNSmlSnapshotItem( iUid ) ));
+					}
+					iIndex++;
+				}
+			}
+			else
+			{
+			iChangeFinder->ItemDeleted( TNSmlSnapshotItem( iUid ) );
+			User::RequestComplete( iCallerStatus, KErrNone );
+			}
+		}
+	}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::StepFailed
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TBool CNSmlContactsDataStore::StepFailed(
+MVPbkContactOperationBase& /*aOperation*/,
+TInt /*aStepSize*/,
+TInt aError )
+{
+if(iLastOperation == ENSmlDeleteOp)
+	{
+	 	if(iBatchMode)
+	 	{
+			if( iIndex < iContactsBufferItemList.Count() &&
+			iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemDelete )
+			{
+			iContactsBufferItemList[iIndex++]->iStatus  = KErrGeneral;
+			iResultArray->Append(KErrGeneral);
+			}
+	 	}
+	 	else
+	 	{
+	 		User::RequestComplete( iCallerStatus, aError );
+	 	}
+	}
+	return ETrue;
+}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::OperationComplete
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::OperationComplete
+		( MVPbkContactOperationBase& aOperation )
+	{
+	MVPbkContactOperationBase* operation = &aOperation;
+	if ( operation )
+	{
+		delete operation;
+		operation = NULL;
+	}
+	TRAPD(error ,OperationCompleteL());
+	if(error != KErrNone)
+		{
+		User::RequestComplete( iCallerStatus, error );
+		}
+	}
+// ---------------------------------------------------------------------------
+//  CNSmlContactsDataStore::OperationCompleteL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNSmlContactsDataStore::OperationCompleteL()
+	{
+	if(iLastOperation == ENSmlDeleteOp)
+		{
+		if(iBatchMode )
+			{
+			if(iResultArray->Count() != iContactsBufferItemList.Count())
+				{
+				while( iIndex < iContactsBufferItemList.Count() &&
+				iContactsBufferItemList[iIndex]->iModType == ENSmlCntItemDelete
+				&& iContactsBufferItemList[iIndex]->iStatus  == KErrNotFound )
+					{
+					iResultArray->Append(KErrNotFound);
+					iIndex++;
+					}
+				}
+			if(iIndex == iContactsBufferItemList.Count())
+				{
+				if(iItemData)
+					{
+					iItemData->Reset();
+					}
+				ResetBuffer();
+				User::RequestComplete( iCallerStatus, KErrNone );
+				}
+				else
+				{
+				ExecuteBufferL();
+				}
+			}
+			else
+			{
+			if(iItemData)
+				{
+				iItemData->Reset();
+				}
+			ResetBuffer();
+			}
+		}
+		else
+		{
+		if(iLastOperation == ENSMLDeleteAllOp)
+	        {
+	        iDeleteAllOperation = NULL;
+	        }
+		if( iChangeFinder )
+			{
+			iChangeFinder->ResetL();
+			}
+		iSnapshotRegistered = EFalse;
+		delete iContactLnks;
+		iContactLnks = NULL;
+		iContactLink = NULL;
+		delete iContactViewBase;
+		iContactViewBase = NULL;
+		User::RequestComplete( iCallerStatus, KErrNone );
+		}
+	}
+// ---------------------------------------------------------------------------
+// CNSmlContactsDataStore::ContactViewReady
+// Implements the view ready function of MVPbkContactViewObserver
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::ContactViewReady(
+MVPbkContactViewBase& /*aView*/ )
+	{
+	if(iLastOperation == ENSMLDeleteAllOp)
+		{
+		TRAPD(error,DoDeleteAllContactsL());
+		if(error != KErrNone)
+			{
+			User::RequestComplete( iCallerStatus, error );
+			}
+		}
+	}
+// ---------------------------------------------------------------------------
+// CNSmlContactsDataStore::PrepareForContactsDeleteL()
+// Delete all the contacts at client
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::DoDeleteAllContactsL()
+	{
+	iContactLnks = CVPbkContactLinkArray::NewL();
+	TInt contactCount = iContactViewBase->ContactCountL();
+	//add all the contact links to  ContactLinkArray
+	for( TInt i = 0; i < contactCount; i++ )
+		{
+			const MVPbkViewContact& contact =
+						iContactViewBase->ContactAtL(i);
+			iContactLink = contact.CreateLinkLC();
+			iContactLnks->AppendL(iContactLink);
+			CleanupStack::Pop();
+		}
+	iDeleteAllOperation = iContactManager->DeleteContactsL( *iContactLnks, *this );
+	}
+// ---------------------------------------------------------------------------
+// CNSmlContactsDataStore::ContactViewUnavailable
+// Implements the view unavailable function of MVPbkContactViewObserver
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::ContactViewUnavailable(
+MVPbkContactViewBase& /*aView*/ )
+	{
+	}
+// ---------------------------------------------------------------------------
+// CNSmlContactsDataStore::ContactAddedToView
+// Implements the add contact function of MVPbkContactViewObserver
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::ContactAddedToView(
+MVPbkContactViewBase& /*aView*/,
+TInt /*aIndex*/,
+const MVPbkContactLink& /*aContactLink*/ )
+	{
+	}
+// ---------------------------------------------------------------------------
+// CNSmlContactsDataStore::ContactRemovedFromView
+// Implements the remove contact function of MVPbkContactViewObserver
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::ContactRemovedFromView(
+MVPbkContactViewBase& /*aView*/,
+TInt /*aIndex*/,
+const MVPbkContactLink& /*aContactLink*/ )
+	{
+	}
+// ---------------------------------------------------------------------------
+// CNSmlContactsDataStore::ContactViewError
+// Implements the view error function of MVPbkContactViewObserver
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::ContactViewError(
+MVPbkContactViewBase& /*aView*/,
+TInt /*aError*/,
+TBool /*aErrorNotified*/ )
+	{
+	}
+// -----------------------------------------------------------------------------
+// CNSmlContactsDataStore::CreateViewL()
+// Create a contact view
+// -----------------------------------------------------------------------------
+EXPORT_C void CNSmlContactsDataStore::CreateViewL()
+	{
+	CVPbkContactViewDefinition* viewDef = CVPbkContactViewDefinition::NewL();
+	CleanupStack::PushL( viewDef );
+	viewDef->SetType( EVPbkContactsView );
+	viewDef->SetUriL(iStore->StoreProperties().Uri().UriDes());
+	 iContactViewBase = iContactManager->CreateContactViewLC(
+				                         *this,
+				                         *viewDef,
+				                         iContactManager->FieldTypes()  );
+	CleanupStack::Pop();
+	CleanupStack::PopAndDestroy(viewDef);
+	}
 // ------------------------------------------------------------------------------------------------
 // CNSmlContactsDataStore::GetStoreFormatResourceFileL
 // ------------------------------------------------------------------------------------------------
-EXPORT_C const TDesC& CNSmlContactsDataStore::GetStoreFormatResourceFileL() const
+EXPORT_C const TDesC& CNSmlContactsDataStore::GetStoreFormatResourceFileL()
 {
-_DBG_FILE("CNSmlContactsDataStore::GetStoreFormatResourceFileL(): BEGIN");
+_DBG_FILE("CNSmlContactsDataStore::GetStoreFormatResourceFileL(): begin");
 // Check correct Data Sync protocol
 TInt value( EDataSyncNotRunning );
 TInt error = RProperty::Get( KPSUidDataSynchronizationInternalKeys,
-KDataSyncStatus,
+KDataSyncStatus, value );
-value );
+if ( error == KErrNone &&
-if ( error == KErrNone && value == EDataSyncRunning )
+value == EDataSyncRunning )
 {
-_DBG_FILE("CNSmlContactsDataStore::GetStoreFormatResourceFileL() 1.1.2: END");
 return KNSmlContactsStoreFormatRsc_1_1_2;
 }
 else // error or protocol version 1.2
 {
-_DBG_FILE("CNSmlContactsDataStore::GetStoreFormatResourceFileL() 1.2: END");
 return KNSmlContactsStoreFormatRsc_1_2;
 }
+_DBG_FILE("CNSmlContactsDataStore::GetStoreFormatResourceFileL(): end");
 }
+// ------------------------------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+// CNSmlContactsDataStore::CreateModsFetcherL
-// CNSmlContactsDataStore::DoExecuteBufferL
+// ------------------------------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+EXPORT_C MContactsModsFetcher* CNSmlContactsDataStore::CreateModsFetcherL()
-EXPORT_C TInt CNSmlContactsDataStore::DoExecuteBufferL(RArray<TInt>& aResultArray)
 {
-_DBG_FILE("CNSmlContactsDataStore::DoExecuteBufferL(): begin");
+_DBG_FILE("CNSmlContactsDataStore::CreateModsFetcherL(): begin");
+CNSmlContactsModsFetcher* modsFetcher =
-TBool batchOK = EFalse;
+new ( ELeave ) CNSmlContactsModsFetcher( iSnapshotRegistered,
-TInt  ret( KErrNone );
+*iContactManager,*iStore, iKey, *iChangeFinder );
-TInt  retCommand( KErrNone );
+CleanupStack::PushL( modsFetcher );
-TInt  itemAdds( 0 );
+modsFetcher->ConstructL();
+CleanupStack::Pop( modsFetcher );
-aResultArray.Reset();
+_DBG_FILE("CNSmlContactsDataStore::CreateModsFetcherL(): end");
+return modsFetcher;
-if( iContactsBufferItemList.Count() == 0 )
-{
-return retCommand;
-}
-TInt i = 0;
-//
-// ResultArray initialized
-//
-while( i<iContactsBufferItemList.Count() )
-{
-if ( iContactsBufferItemList[i]->iModType == ENSmlCntItemAdd &&
-iContactsBufferItemList[i]->iStatus  == KNSmlNoError )
-{
-itemAdds++;
-}
-aResultArray.Append( KErrGeneral );
-i++;
-}
-i = 0;
-//
-// Loop through buffered commands
-//
-while( i<iContactsBufferItemList.Count() )
-{
-if( iContactsBufferItemList[i]->iStatus!= KNSmlNoError )
-{
-retCommand = iContactsBufferItemList[i]->iStatus;
-}
-else if( iContactsBufferItemList[i]->iModType == ENSmlCntItemAdd )
-{
-ret =0 ;
-iPUid  = 0;
-StripPropertyL( iItemDataAddBatch, KVersitTokenUID() ); // Remove UID's from data
-TInt err( KErrNone );
-TTime lastModified;
-if( iBatchMode )    // All adds handled when first add on iContactsBufferItemList
-{
-iAddResultArray.Reset();
-TRAP( err, ret = LdoAddItemsL( iAddResultArray, iItemDataAddBatch,
-iItemDataAddBatch->Ptr(0).Length(),
-lastModified ) );
-if( err == KErrNone && ret == KErrNone &&
-itemAdds == iAddResultArray.Count() )
-{
-TInt j = i;
-TInt k = 0;
-while( j < iContactsBufferItemList.Count() )
-{
-if( iContactsBufferItemList[j]->iModType == ENSmlCntItemAdd &&
-iContactsBufferItemList[j]->iStatus  == KNSmlNoError &&
-k < iAddResultArray.Count() )
-{
-iContactsBufferItemList[j]->iStatus = KErrNone;
-*iContactsBufferItemList[j]->iPUid = iAddResultArray[k];
-TNSmlSnapshotItem item( iAddResultArray[k]);
-item.SetLastChangedDate( lastModified );
-item.SetSoftDelete( EFalse );
-iChangeFinder->ItemAddedL( item );
-k++;
-}
-j++;
-}
-}
-else
-{
-TInt j = i;
-while( j < iContactsBufferItemList.Count() )
-{
-if( iContactsBufferItemList[j]->iModType == ENSmlCntItemAdd &&
-iContactsBufferItemList[j]->iStatus  == KNSmlNoError )
-{
-iContactsBufferItemList[j]->iStatus = KErrNotSupported;
-}
-j++;
-}
-}
-}
-else
-{
-TTime lastModified;
-iPUid  =iContactsBufferItemList[i]->iPUid;
-const TPtr8 dataPtr = iItemDataAddBatch->Ptr(0);
-TRAP( err, ret = LdoAddItemL(*iPUid, dataPtr,
-iContactsBufferItemList[i]->iSize,
-lastModified));
-if( (err == KErrNone) && (ret == KErrNone))
-{
-// Add the snapshot item to the Change Finder.
-// The Change finder maintains a list of all changes to the database.
-TNSmlSnapshotItem item( *iPUid );
-item.SetLastChangedDate( lastModified );
-item.SetSoftDelete( EFalse );
-iChangeFinder->ItemAddedL( item );
-retCommand = KErrNone;
-}
-else if( err == KErrNone )
-{
-retCommand = ret;
-}
-else
-{
-retCommand = err;
-}
-}
-}
-else if( iContactsBufferItemList[i]->iModType == ENSmlCntItemReplace  ||
-iContactsBufferItemList[i]->iModType == ENSmlCntItemFieldLevelReplace )
-{
-iItemData = iContactsBufferItemList[i]->iItemData;
-iUid  = iContactsBufferItemList[i]->iUid;
-const TPtr8 dataPtr = iItemData->Ptr(0);
-ret = 0;
-TTime lastModified;
-TRAPD( err, ret = LdoUpdateItemL(iUid, dataPtr,
-iContactsBufferItemList[i]->iSize,
-lastModified ));
-if( (err == KErrNone) && (ret == KErrNone) )
-{
-retCommand = KErrNone;
-iContactsBufferItemList[i]->iStatus = KErrNone;
-TNSmlSnapshotItem item( iUid );
-item.SetLastChangedDate( lastModified );
-item.SetSoftDelete( EFalse );
-iChangeFinder->ItemUpdatedL( item );
-}
-else if( err == KErrNone )
-{
-retCommand = ret;
-iContactsBufferItemList[i]->iStatus = ret;
-}
-else
-{
-retCommand = err;
-iContactsBufferItemList[i]->iStatus = err;
-}
-iItemData = NULL;
-}
-else if( iContactsBufferItemList[i]->iModType == ENSmlCntItemMove )
-{
-retCommand = KErrNotSupported;
-}
-else if( iContactsBufferItemList[i]->iModType == ENSmlCntItemDelete ||
-iContactsBufferItemList[i]->iModType == ENSmlCntItemSoftDelete )
-{
-if( iBatchMode )    // All deletes handled when 1'st occurrence on list
-{
-CArrayFixFlat<TUid>* arrDelete = new(ELeave) CArrayFixFlat<TUid>(4);
-CleanupStack::PushL( arrDelete );
-TInt j=i;
-while( j < iContactsBufferItemList.Count() )
-{
-if( (iContactsBufferItemList[j]->iModType == ENSmlCntItemDelete ||
-iContactsBufferItemList[j]->iModType == ENSmlCntItemSoftDelete) &&
-iContactsBufferItemList[j]->iStatus  == KNSmlNoError )
-{
-TUid id = TUid::Uid( iContactsBufferItemList[j]->iUid );
-CNsmlContactItem* contactitem = CNsmlContactItem::NewL();
-CleanupStack::PushL( contactitem );
-TInt err = KErrNone;
-TInt ret = KErrNone;
-TRAP( err, ret = iContactsDataStoreExtension->ReadContactL( id, contactitem ) );
-if( err == KErrNone && ret == KErrNone && id.iUid != 0 )
-{
-arrDelete->AppendL( id );
-}
-else if( err == KErrNone && ret == KErrNone )
-{
-iContactsBufferItemList[j]->iStatus  = KErrNotFound;
-}
-else
-{
-iContactsBufferItemList[j]->iStatus  = err;
-}
-CleanupStack::PopAndDestroy( contactitem ); // item
-}
-j++;
-}
-if( arrDelete->Count() > 0 )
-{
-TInt err2 = KErrInUse;
-TRAP( err2, iContactsDataStoreExtension->DeleteContactsL( arrDelete ) );
-CleanupStack::PopAndDestroy( arrDelete );
-if( err2 == KErrInUse )
-{
-err2 = KErrGeneral;
-}
-j= i;
-while( j < iContactsBufferItemList.Count() ) // Mark deleted items
-{
-if( iContactsBufferItemList[j]->iModType == ENSmlCntItemDelete &&
-iContactsBufferItemList[j]->iStatus  == KNSmlNoError )
-{
-iContactsBufferItemList[j]->iStatus  = err2;
-if( err2 == KErrNone )
-{
-iUid  = iContactsBufferItemList[j]->iUid;
-iChangeFinder->ItemDeleted( TNSmlSnapshotItem( iUid ));
-}
-}
-else if( iContactsBufferItemList[j]->iModType == ENSmlCntItemSoftDelete &&
-iContactsBufferItemList[j]->iStatus  == KNSmlNoError )
-{
-iContactsBufferItemList[j]->iStatus  = err2;
-if( err2 == KErrNone )
-{
-iUid  = iContactsBufferItemList[j]->iUid;
-iChangeFinder->ItemSoftDeletedL( TNSmlSnapshotItem( iUid ) );
-}
-}
-j++;
-}
-}
-else
-{
-CleanupStack::PopAndDestroy( arrDelete );
-}
-}
-else
-{
-iUid  = iContactsBufferItemList[i]->iUid;
-TInt err = KErrNone;
-TRAP( err, iContactsDataStoreExtension->DeleteContactL( TUid::Uid( iUid ) ) );
-if( err == KErrNone )
-{
-iChangeFinder->ItemDeleted( TNSmlSnapshotItem( iUid ) );
-}
-iContactsBufferItemList[i]->iStatus  = err;
-retCommand = err;
-}
-}
-//
-//  Set allready set commands from iContactsBufferItemList
-//
-if( ( iContactsBufferItemList[i]->iModType == ENSmlCntItemAdd     ||
-iContactsBufferItemList[i]->iModType == ENSmlCntItemReplace ||
-iContactsBufferItemList[i]->iModType == ENSmlCntItemFieldLevelReplace ||
-iContactsBufferItemList[i]->iModType == ENSmlCntItemDelete  ||
-iContactsBufferItemList[i]->iModType == ENSmlCntItemSoftDelete ) &&
-iContactsBufferItemList[i]->iStatus  != KNSmlNoError )
-{
-retCommand = iContactsBufferItemList[i]->iStatus;
-}
-if( !batchOK && retCommand == KErrNone ) // If one command is OK => batchOK
-{
-batchOK = ETrue;
-}
-aResultArray[i++] = retCommand;
-}
-if ( batchOK )
-{
-_DBG_FILE("CNSmlContactsDataStore::DoExecuteBufferL(): end");
-return KErrNone;
-}
-_DBG_FILE("CNSmlContactsDataStore::DoExecuteBufferL(): ERROR end");
-return KErrGeneral; // All commands failed
 }
 // ------------------------------------------------------------------------------------------------
-// CNSmlContactsDataStore::FetchModificationsL
+// CNSmlContactsDataStore::GetDataMod
 // ------------------------------------------------------------------------------------------------
-//
-TInt CNSmlContactsDataStore::FetchModificationsL()
-{
-_DBG_FILE("CNSmlContactsDataStore::FetchModificationsL(): begin");
-TInt error = KErrNone;
-if( !iSnapshot )
-{
-iSnapshot = new (ELeave) CArrayFixSeg<TNSmlSnapshotItem>( KNSmlContactsGranularity );
-}
-iCntUidList->Reset();
-iContactsDataStoreExtension->ListContactsL( iCntUidList );
-if( !iSnapshotRegistered )
-{
-DBG_ARGS(_S("CNSmlContactsDataStore::FetchModificationsL(): Count = %d"), iCntUidList->Count());
-for ( TInt i = 0; i < iCntUidList->Count(); i++ )
-{
-CNsmlContactItem* contactitem = CNsmlContactItem::NewL();
-CleanupStack::PushL( contactitem );
-error = iContactsDataStoreExtension->ReadContactL( iCntUidList->At(i), contactitem );
-if(error != KErrNone)
-{
-DBG_ARGS(_S("CNSmlContactsDataStore::FetchModificationsL(): Error = %d"), error);
-CleanupStack::PopAndDestroy(contactitem); // item
-return error;
-}
-TNSmlSnapshotItem snap( iCntUidList->At(i).iUid  );
-snap.SetLastChangedDate( contactitem->iLastModified );
-iSnapshot->InsertIsqL( snap, iKey );
-CleanupStack::PopAndDestroy(contactitem); // item
-}
-iSnapshot->Compress();
-iChangeFinder->SetNewSnapshot( iSnapshot ); // changefinder takes ownership
-iSnapshot = NULL;
-iSnapshotRegistered = ETrue;
-}
-_DBG_FILE("CNSmlContactsDataStore::FetchModificationsL(): end");
-return KErrNone;
-}
-// ----------------------------------------------------------------------------»
-// CNSmlContactsDataStore::GetDataMod
-// return reference to datamod instance.
-// ----------------------------------------------------------------------------
 EXPORT_C CNSmlDataModBase& CNSmlContactsDataStore::GetDataMod()
 {
+_DBG_FILE("CNSmlContactsDataStore::GetDataMod()");
 return *iDataMod;
 }
-// ----------------------------------------------------------------------------
-// CNSmlContactsDataStore::ExportContactsL
-// ----------------------------------------------------------------------------
-EXPORT_C TInt CNSmlContactsDataStore::ExportContactsL(
-const TUid& aUid, CBufBase& aContactBufBase )
-{
-return iContactsDataStoreExtension->ExportContactsL( aUid, aContactBufBase );
-}
-// ----------------------------------------------------------------------------
-// CNSmlContactsDataStore::ImportContactsL
-// ----------------------------------------------------------------------------
-EXPORT_C CArrayFixFlat<TUid>* CNSmlContactsDataStore::ImportContactsL(
-const TDesC8& aContactBufBase )
-{
-return iContactsDataStoreExtension->ImportContactsL( aContactBufBase );
-}
 // End of File

branch	RCL_3
changeset 52	4f0867e42d62
parent 51	8e7494275d3a
child 56	3e6957da2ff8