// Copyright (c) 1998-2009 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:

//

#include <s32std.h>

#include "MSVIPC.H"

#include "MSVIDS.H"

#include "MSVPANIC.H"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "msvsearchsortconstants.h"

#include "msvconsts.h"

#endif

GLDEF_C void DoUnpackEntry(TUint8*& aPtr, TMsvEntry& aEntry)

//

//

//

	{

	// get the entry from the start of the buffer

	const TMsvEntry* pEntry = (TMsvEntry*) aPtr;

	aEntry = *pEntry;

	aPtr = Align4(aPtr + sizeof(TMsvEntry));

	const TText* textPtr = (TText*)aPtr;

	TInt length=aEntry.iDescription.Length();

	aEntry.iDescription.Set(textPtr, length);

	textPtr = Align4(textPtr + length);

	length=aEntry.iDetails.Length();

	aEntry.iDetails.Set(textPtr, length);

	textPtr = Align4(textPtr + length);

	aPtr = (TUint8*) textPtr;

	}

GLDEF_C TInt DoPackEntry(const TUint8*& aPtrStart, const TUint8* aPtrEnd, const TMsvEntry& aEntry)

//

// Packs an entry into the memory area defined by the two pointers.

// Fails with KErrOverflow if the packed entry is too large

// aPtrStart is always returned pointing to the end of the packed entry (even if too large)

//

	{

	// make sure the entry can fit into the memory area defined by the two pointers

	TInt sizeEntry = Align4(sizeof(TMsvEntry));

	TInt sizeString1 = Align4(aEntry.iDescription.Size());

	TInt sizeString2 = Align4(aEntry.iDetails.Size());

	TInt size =  sizeEntry + sizeString1 + sizeString2;

	if ((aPtrStart + size)>aPtrEnd)

		{

		aPtrStart += size;

		return KErrOverflow;

		}

	// copy the entry and descriptors into the memory area

	Mem::Copy((void*)aPtrStart, &aEntry, sizeof(TMsvEntry));

	aPtrStart += sizeEntry;

	Mem::Copy((void*)aPtrStart, aEntry.iDescription.Ptr(), aEntry.iDescription.Size());

	aPtrStart += sizeString1;

	Mem::Copy((void*)aPtrStart, aEntry.iDetails.Ptr(), aEntry.iDetails.Size());

	aPtrStart += sizeString2;

	return KErrNone;

	}

GLDEF_C void DoUnpackFilter(TUint8*& aPtr, CMsvEntryFilter& aFilter)

//

//

//

	{

	// get the entry from the start of the buffer

	const CMsvEntryFilter* pFilter = (CMsvEntryFilter*) aPtr;

	Mem::Copy(&aFilter, pFilter, sizeof(CMsvEntryFilter));

	aPtr = Align4(aPtr + sizeof(CMsvEntryFilter));

	}

GLDEF_C TInt DoPackFilter(const TUint8*& aPtrStart, const TUint8* aPtrEnd, const CMsvEntryFilter& aFilter)

//

//

//

	{

	// make sure the entry can fit into the memory area defined by the two pointers

	TInt size = Align4(sizeof(CMsvEntryFilter));

	if ((aPtrStart + size)>aPtrEnd)

		{

		aPtrStart += size;

		return KErrOverflow;

		}

	// copy the filter into the memory area

	Mem::Copy((void*)aPtrStart, &aFilter, sizeof(CMsvEntryFilter));

	aPtrStart += size;

	return KErrNone;

	}

//**********************************

// TMsvPackedEntry

//**********************************

EXPORT_C TMsvPackedEntry::TMsvPackedEntry(HBufC8*& aBuffer)

: iBuffer(aBuffer)

	{}

EXPORT_C TInt TMsvPackedEntry::PackEntry(const TMsvEntry& aEntry)

//

//

//

	{

	// find the start and end of the buffer

	const TUint8* pS = iBuffer->Ptr();

	const TUint8* pE = PtrAdd(pS, iBuffer->Des().MaxSize());

	TInt error = DoPackEntry(pS, pE, aEntry);

	if (error==KErrNone)

		{

		// update the length of the buffer

		iBuffer->Des().SetLength(pS-iBuffer->Ptr());

		}

	return error;

	}

EXPORT_C void TMsvPackedEntry::UnpackEntry(TMsvEntry& aEntry)

//

//

//

	{

#if defined(_DEBUG)

	// check that the buffer contain a valid package

	const TMsvEntry* dEntry = (TMsvEntry*) iBuffer->Ptr();

	const TUint8* dPos = PtrAdd(iBuffer->Ptr(), Align4(sizeof(TMsvEntry)) + Align4(dEntry->iDescription.Size()) + Align4(dEntry->iDetails.Size()));

	__ASSERT_DEBUG(dPos <= PtrAdd(iBuffer->Ptr(), iBuffer->Des().MaxLength()), PanicServer(EMsvEntryOverrunBuffer));

#endif

	TUint8* pS = CONST_CAST(TUint8*, iBuffer->Ptr());

	DoUnpackEntry(pS, aEntry);

	}

//**********************************

// TMsvPackedEntryArray

//**********************************

EXPORT_C TMsvPackedEntryArray::TMsvPackedEntryArray(HBufC8*& aBuffer, TInt aCount)

: iIndex(0), iCount(aCount), iBuffer(aBuffer) 

	{

	iPos = iBuffer->Ptr();

	}

EXPORT_C void TMsvPackedEntryArray::Reset()

//

//

//

	{

	iBuffer->Des().SetLength(0);

	iPos  = iBuffer->Ptr();

	iIndex=0;

	iCount=0;

	}

EXPORT_C TInt TMsvPackedEntryArray::PackEntry(const TMsvEntry& aEntry)

//

//

//

	{

	const TUint8* pS = iPos;

	const TUint8* pE = PtrAdd(iBuffer->Ptr(), iBuffer->Des().MaxSize());

	TInt error = DoPackEntry(pS, pE, aEntry);

	if (error==KErrNone)

		{

		// update the length of the buffer and the position for the next entry

		iBuffer->Des().SetLength(pS-iBuffer->Ptr());

		iPos = pS;

		iIndex++;

		iCount++;

		}

	return error;

	}

EXPORT_C TInt TMsvPackedEntryArray::UnpackEntry(TInt aIndex, TMsvEntry& aEntry)

//

//

//

	{

	TInt error=KErrNone;

	if (iIndex!=aIndex)

		error = FindEntryInArray(aIndex);

	if (error==KErrNone)

		{

		TUint8* pS=CONST_CAST(TUint8*, iPos);

		DoUnpackEntry(pS, aEntry);

		iPos=pS;

		iIndex++;

		}	

	return error;

	}

TInt TMsvPackedEntryArray::FindEntryInArray(TInt aIndex)

//

//

//

	{

	if (aIndex>=iCount)

		return KErrNotFound;

	if (iIndex>aIndex)

		{

		// have to reset to the start of the buffer

		iPos = iBuffer->Ptr();

		iIndex=0;

		}

	while (iIndex!=aIndex)

		{

		const TMsvEntry* pEntry = (TMsvEntry*) iPos;

		iPos += Align4(sizeof(TMsvEntry)) + Align4(pEntry->iDescription.Size()) + Align4(pEntry->iDetails.Size());

		iIndex++;

		}

	__ASSERT_DEBUG(iPos < PtrAdd(iBuffer->Ptr(), iBuffer->Des().MaxLength()), PanicServer(EMsvPointerOverrunBuffer));

	return KErrNone;

	}

//**********************************

// TMsvMoveCopyDetails

//**********************************

EXPORT_C TMsvLocalOperationProgress::TMsvLocalOperationProgress()

: iType(ELocalNone), iTotalNumberOfEntries(0), iNumberCompleted(0), iNumberFailed(0), iNumberRemaining(0), iError(KErrNone), iId(KMsvNullIndexEntryId)

/** Initialises the new object to suitable zero or null values. */

	{

	}

//**********************************

// TMsvServerOperationProgress

//**********************************

EXPORT_C TMsvServerOperationProgress::TMsvServerOperationProgress()

: iOperationType(EMsvNoOperation)

/** Default constructor.

Sets iOperationType to EMsvNoOperation. */

	{

	}

TMsvServerOperationProgress::TMsvServerOperationProgress(TMsvServerOperationType aType)

: iOperationType(aType)

	{

	}

//**********************************

// TMsvIndexProgress

//**********************************

EXPORT_C TMsvIndexProgress::TMsvIndexProgress()

: iTotal(0), iCompleted(0), iRemaining(0), iId(KMsvNullIndexEntryId)

/** Default constructor.

Data members are intialised to 0 or KMsvNullIndexEntryId as appropriate. */

	{

	}

//**********************************

// TMsvIndexLoadProgress

//**********************************

EXPORT_C TMsvIndexLoadProgress::TMsvIndexLoadProgress()

: TMsvServerOperationProgress(EMsvChangeDriveOperation), iError(KErrNone), iState(EIndexNotLoaded)

/** Default constructor.

iOperationType is set to EMsvChangeDriveOperation; iError is set to KErrNone; 

iState is set to EIndexNotLoaded. */

	{

	}

//**********************************

// TMsvCopyProgress

//**********************************

/** Default constructor.

iOperationType is set to EMsvCopyOperation; iError is set to KErrNone; 

iState is set to ENotYetStarted. */  

EXPORT_C TMsvCopyProgress::TMsvCopyProgress()

: TMsvServerOperationProgress(EMsvCopyOperation), iError(KErrNone), iState(ENotYetStarted)

	{

	}

//**********************************

// TMsvDeleteProgress

//**********************************

/** Default constructor.

iOperationType is set to EMsvDeleteOperation; iError is set to KErrNone; 

iState is set to ENotYetStarted. */

EXPORT_C TMsvDeleteProgress::TMsvDeleteProgress()

: TMsvServerOperationProgress(EMsvDeleteOperation), iError(KErrNone), iState(ENotYetStarted)

	{

	}

//**********************************

// TMsvChildrenDetails

//**********************************

EXPORT_C TMsvChildrenDetails::TMsvChildrenDetails()

: iParentId(KMsvNullIndexEntryId), iTotalNumberChildren(0), iNumberChildrenInArray(0), iLastEntryInArray(0)

	{

	}

//**********************************

// TMsvPackedOperation

//**********************************

EXPORT_C TMsvPackedOperation::TMsvPackedOperation(HBufC8*& aBuffer)

: iBuffer(aBuffer)

	{

	}

EXPORT_C TInt TMsvPackedOperation::Pack(const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2)

	{

	// check the buffer is large enough

	TInt requiredSize = (aSelection.Count()+3)*4;

	if (requiredSize>iBuffer->Des().MaxSize())

		return KErrOverflow;

	// set the buffer with correct length

	iBuffer->Des().SetLength(requiredSize);

	TInt* ptr = (TInt*) CONST_CAST(TUint8*, iBuffer->Ptr());

	*ptr++ = aSelection.Count();

	for (TInt count=0; count<aSelection.Count(); count++)

		*ptr++ = aSelection.At(count);

	*ptr++ = aParameter1;

	*ptr++ = aParameter2;

	return KErrNone;

	}

EXPORT_C void TMsvPackedOperation::UnpackL(CMsvEntrySelection& aSelection, TInt& aParameter1, TInt& aParameter2)

	{

	__ASSERT_DEBUG(aSelection.Count()==0, PanicServer(EMsvOperationUnpackSelectionNotEmpty));	

	TInt* ptr = (TInt*) CONST_CAST(TUint8*, iBuffer->Ptr());

	TInt count = *ptr++;

	TInt bufSize = iBuffer->Des().Length();

	// This length is calculated on the basis of length set in TMsvPackedOperation::Pack above.

	TInt len = (count+3)*4; 

	if(bufSize == len)	

		{

		while (count--)

			{

			aSelection.AppendL(*ptr++);

			}

		aParameter1 = *ptr++;

		aParameter2 = *ptr++;

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

EXPORT_C TMsvPackedChangeNotification::TMsvPackedChangeNotification(TMsvNotifBuffer& aBuffer)

: iBuffer(aBuffer)

	{

	}

EXPORT_C void TMsvPackedChangeNotification::Pack(TMsvServerChangeNotificationType aChangeType, const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2, TInt aStartIndex, TInt aFinishIndex)

//

// Packs the aStartIndex->aFinishIndex (inc) into the buffer

//

	{

	__ASSERT_DEBUG(aFinishIndex-aStartIndex+1<=KMsvPackedChangeLimit, PanicServer(EMsvChangeSelectionTooLarge));

	// set the buffer with correct length

	TInt requiredSize = (aFinishIndex-aStartIndex+1+KMsvChangeNotificationNumberOfTInts)*4;

	iBuffer.SetLength(requiredSize);

	TInt* ptr = (TInt*) CONST_CAST(TUint8*, iBuffer.Ptr());

	*ptr++ = aChangeType;

	*ptr++ = aParameter1;

	*ptr++ = aParameter2;

	*ptr++ = aFinishIndex - aStartIndex + 1;

	for (TInt count=aStartIndex; count<=aFinishIndex; count++)

		*ptr++ = aSelection.At(count);

	}

EXPORT_C void TMsvPackedChangeNotification::Pack(TMsvServerChangeNotificationType aChangeType, TMsvId aId, TInt aParameter1, TInt aParameter2)

//

// Packs a single id

//

	{

	// set the buffer with correct length

	TInt requiredSize = (1+KMsvChangeNotificationNumberOfTInts)*4;

	iBuffer.SetLength(requiredSize);

	TInt* ptr = (TInt*) CONST_CAST(TUint8*, iBuffer.Ptr());

	*ptr++ = aChangeType;

	*ptr++ = aParameter1;

	*ptr++ = aParameter2;

	*ptr++ = 1;

	*ptr++ = aId;

	}

EXPORT_C void TMsvPackedChangeNotification::UnpackL(TMsvServerChangeNotificationType& aChangeType, CMsvEntrySelection& aSelection, TInt& aParameter1, TInt& aParameter2)

//

//

//

	{

	__ASSERT_DEBUG(aSelection.Count()==0, PanicServer(EMsvChangedUnpackSelectionNotEmpty));	

	TInt* ptr = (TInt*) CONST_CAST(TUint8*, iBuffer.Ptr());

	switch (*ptr++)

		{

		case 1:

			aChangeType = EMsvEntriesCreated;

			break;

		case 2:

			aChangeType = EMsvEntriesChanged;

			break;

		case 3:

			aChangeType = EMsvEntriesDeleted;

			break;

		case 4:

			aChangeType = EMsvEntriesMoved;

			break;

		case 5:

			aChangeType = EMsvMtmGroupInstalled;

			break;

		case 6:

			aChangeType = EMsvMtmGroupDeInstalled;

			break;

		case 8:

			aChangeType = EMsvCloseSession;

			break;

		case 9:

			aChangeType = EMsvIndexLoaded;

			break;

		case 10:

			aChangeType = EMsvIndexFailedToLoad;

			break;

		case 12:

			aChangeType = EMsvMediaChanged;

			break;

		case 13:

			aChangeType = EMsvMediaUnavailable;

			break;

		case 14:

			aChangeType = EMsvMediaAvailable;

			break;

		case 15:

			aChangeType = EMsvMediaIncorrect;

			break;

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

		case 16:

			aChangeType = EMsvMessageStoreNotSupported;

			break;

		case 17:

			aChangeType = EMsvMessageStoreCorrupt;

			break;

		case 18:

			aChangeType = EMsvRefreshMessageView;

			break;

		case 19:

			aChangeType = EMsvDiskNotAvailable;

			break;

		case 20:

			aChangeType = EMsvUnableToProcessDiskNotification;

			break;

#endif	

		default:

			__ASSERT_DEBUG(EFalse, PanicServer(EMsvUnknownChangeType));

			aChangeType = EMsvEntriesNoChange;

		}

	aParameter1 = *ptr++;

	aParameter2 = *ptr++;

	TInt count = *ptr++;

	while (count--)

		aSelection.AppendL(*ptr++);

	}

TMsvPackedEntryFilter::TMsvPackedEntryFilter(HBufC8*& aBuffer)

: iBuffer(aBuffer)

	{}

TInt TMsvPackedEntryFilter::PackFilter(const CMsvEntryFilter& aFilter)

	{