// 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 <e32std.h>

#include "MSVSTD.H"

#include "MSVSTORE.H"

#include "MSVIDS.H"

#include "MSVENTRY.H"

#include "MSVSERV.H"

#include "MSVMOVE.H"

#include "MSVDELET.H"

#include "MSVCOPY.H"

#include "MSVPANIC.H"

#include "MSVUTILS.H"

#include "msvindexadapter.h"

const TInt KMsvServerEntryStandardBufLength=64;

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

// CMsvServerEntry

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

// static

/**

@internalComponent

*/

EXPORT_C CMsvServerEntry* CMsvServerEntry::NewL(CMsvServer& aServer, TMsvId aId)

//

//

//

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aId);

	CleanupStack::Pop();

	return self;

	}

CMsvServerEntry::CMsvServerEntry(CMsvServer& aServer)

: CActive(EPriorityStandard), iLockedStore(EFalse), iServer(aServer)

//

//

//

	{

	__DECLARE_NAME(_S("CMsvServerEntry"));

	}

void CMsvServerEntry::ConstructL(TMsvId aId)

//

//

//

	{

	iDescription = HBufC::NewL(KMsvServerEntryStandardBufLength);

	iDetails	 = HBufC::NewL(KMsvServerEntryStandardBufLength);

	User::LeaveIfError(SetEntry(aId));

	CActiveScheduler::Add(this);

	}

CMsvServerEntry::~CMsvServerEntry()

//

//

//

/** Frees resources for the object. It:

1. releases the lock on the entry

2. releases the lock on the associated message store if has been opened with

EditStoreL()

3. cancels any outstanding asynchronous MoveEntryL() move operation */

	{

	__ASSERT_DEBUG(iStore==NULL, PanicServer(EMsvStoreLeftOpenOnDestruction));

	if (iEntry.Id() != KMsvNullIndexEntryId)

		{

		iServer.IndexAdapter().ReleaseEntry(iEntry.Id()); // ignore any error

		}

	if (iLockedStore)

		{

		iServer.IndexAdapter().ReleaseStore(iEntry.Id()); // ignore any error

		}

	delete iDescription;

	delete iDetails;

	Cancel();

	}

EXPORT_C TInt CMsvServerEntry::SetEntry(TMsvId aId)

//

// Changes the entry used as the context

//

/** Changes the context of the specified entry.

The call locks the entry, preventing it from being accessed by other clients.

The lock is released when the object is deleted or the context is changed.

Note that you can change the context to KMsvNullIndexEntryId to unlock an

entry without locking another.

@param aId ID of the entry to access

@return KErrNone if successful, KErrNotFound if the entry does not exist, or

KErrLocked if the entry is locked. */

	{

	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvEntryStoreLeftOpen));

	__ASSERT_ALWAYS(iEntryState==EMsvIdle, PanicServer(EMsvServerEntryNotIdle));

	// changing to itself

	if (iEntry.Id()==aId)

		return KErrNone;

	if (aId == KMsvNullIndexEntryId)

		{

		// setting the context to NULL

		iServer.IndexAdapter().ReleaseEntry(iEntry.Id()); // error ignored

		*iDescription = TPtrC();

		*iDetails = TPtrC();

		iEntry = TMsvEntry();

		return KErrNone;

		}

	// lock the new entry

	TInt error = KErrNone;

    error = iServer.IndexAdapter().LockEntry(aId);

	if (error)

		return error;

	// get the new entry

	TMsvEntry* entryPtr;

	error = iServer.IndexAdapter().GetEntry(aId, entryPtr, iContextOwnerId);

	if (error==KErrNone)

		{

		// check we can copy the strings

		error = IncreaseBufferSizes(entryPtr->iDescription.Length(), entryPtr->iDetails.Length());

		if (error==KErrNone)

			{

			// release old entry

			if (iEntry.Id()!=KMsvNullIndexEntryId)

				{

				iServer.IndexAdapter().ReleaseEntry(iEntry.Id()); // error ignored

				}

			// switch the context of this object

			*iDescription = entryPtr->iDescription;

			*iDetails = entryPtr->iDetails;

			iEntry = *entryPtr;

			iEntry.iDescription.Set(*iDescription);

			iEntry.iDetails.Set(*iDetails);

			}

		}

	// release the lock on the new entry

	if (error)

		{

		iServer.IndexAdapter().ReleaseEntry(aId); // error ignored

		}

	return error;

	}

TInt CMsvServerEntry::IncreaseBufferSizes(TInt aNewDescriptionSize, TInt aNewDetailsSize)

//

// Increase the size of the buffers if needed. The current contents of the buffers is maintained

//

	{

	if (aNewDescriptionSize > iDescription->Des().MaxLength())

		{

		HBufC* newBuf = iDescription->ReAlloc(aNewDescriptionSize);

		if (newBuf==NULL)

			return KErrNoMemory;

		iDescription=newBuf;

		}

	if (aNewDetailsSize > iDetails->Des().MaxLength())

		{

		HBufC* newBuf = iDetails->ReAlloc(aNewDetailsSize);

		if (newBuf==NULL)

			return KErrNoMemory;

		iDetails=newBuf;

		}

	return KErrNone;

	}

/**

Sets the context's index entry to the specified values.

@param	aEntry

The new details for the entry.

@return

KErrNone - success; KErrAccessDenied - the entry is read only (deleted

entry, standard folder, or locked); KErrNotSupported - aEntry is invalid or the

ID specified in aEntry is not the same as the context ID or no context has been

set for the object; KErrNoMemory - a memory allocation failed.

*/

EXPORT_C TInt CMsvServerEntry::ChangeEntry(const TMsvEntry& aEntry)

	{

	return DoChangeEntry(aEntry, KMsvServerId, EFalse, EFalse);

	}

/**

Sets the context's index entry to the specified values and updates the owner of

the entry to that specified by the supplied ID.

@param	aEntry

The new details for the entry.

@param	aOwnerId

The ID of the process that should own the entry.

@return

KErrNone - success; KErrAccessDenied - the entry is read only (deleted

entry, standard folder, or locked); KErrNotSupported - aEntry is invalid or the

ID specified in aEntry is not the same as the context ID or no context has been

set for the object; KErrNoMemory - a memory allocation failed.

*/

EXPORT_C TInt CMsvServerEntry::ChangeEntry(const TMsvEntry& aEntry, TSecureId aOwnerId)

	{

	return DoChangeEntry(aEntry, aOwnerId, ETrue, EFalse);

	}

/**

Sets the context's index entry to the specified values and updates the owner of

the entry to that specified by the supplied ID. It does this as part of a bulk

operation, so the changes are not immediately committed to file.

@param	aEntry

The new details for the entry.

@param	aOwnerId

The ID of the process that should own the entry. Only commits changes to

file at specified bulk commit interval.

@return

KErrNone - success; KErrAccessDenied - the entry is read only (deleted

entry, standard folder, or locked); KErrNotSupported - aEntry is invalid or the

ID specified in aEntry is not the same as the context ID or no context has been

set for the object; KErrNoMemory - a memory allocation failed.

*/

EXPORT_C TInt CMsvServerEntry::ChangeEntryBulk(const TMsvEntry& aEntry, TSecureId aOwnerId)

	{

	return DoChangeEntry(aEntry, aOwnerId, ETrue, ETrue);

	}

/**

Sets the context's index entry to the specified values and updates the owner of

the entry to that specified by the supplied ID. It does this as part of a bulk

operation, so the changes are not immediately committed to file.

@param	aEntry

The new details for the entry.

@return

KErrNone - success; KErrAccessDenied - the entry is read only (deleted

entry, standard folder, or locked); KErrNotSupported - aEntry is invalid or the

ID specified in aEntry is not the same as the context ID or no context has been

set for the object; KErrNoMemory - a memory allocation failed.

*/

EXPORT_C TInt CMsvServerEntry::ChangeEntryBulk(const TMsvEntry& aEntry)

	{

	return DoChangeEntry(aEntry, KMsvServerId, EFalse, ETrue);

	}

TInt CMsvServerEntry::DoChangeEntry(const TMsvEntry& aEntry, TSecureId aOwnerId, TBool aForcedUpdate, TBool aBulk)

	{

	__ASSERT_DEBUG(iEntry.Id()!=KMsvNullIndexEntryId, PanicServer(EMsvEntryWithNoContext1));

	__ASSERT_DEBUG(aEntry.Id()==iEntry.Id(), PanicServer(EMsvNotChangingCurrentContext));

	__ASSERT_DEBUG(MsvUtils::ValidEntry(aEntry), PanicServer(EMsvBadEntryContents));

	__ASSERT_DEBUG(!iEntry.Deleted(), PanicServer(EMsvChangingDeletedEntry));

	// can only change the context, and must be valid

	if (iEntry.Id()==KMsvNullIndexEntryId || aEntry.Id()!=iEntry.Id() || !MsvUtils::ValidEntry(aEntry))

		return KErrNotSupported;

	if (iEntry.Deleted() || iEntry.StandardFolder())

		return KErrAccessDenied;

	TInt error;

	TBool permanentDataUnchanged = iEntry.PermanentDataUnchanged(aEntry);

	if( permanentDataUnchanged && aForcedUpdate )

		{

		// Check to see if the owner ID is being updated - if so then need to

		// update the permanent data.

		permanentDataUnchanged = (iContextOwnerId == aOwnerId);

		}

	if( permanentDataUnchanged )

		{

		error = iServer.IndexAdapter().ChangeTemporaryData(aEntry);

		if (error==KErrNone)

			iEntry.iData = aEntry.iData;

		}

	else

		{

		error = IncreaseBufferSizes(aEntry.iDescription.Length(), aEntry.iDetails.Length());

		if (error==KErrNone)

			{

			TMsvEntry entry = aEntry;

			// check the hidden flags are correct

			entry.SetOwner(iEntry.Owner());

			entry.SetDeleted(iEntry.Deleted());

			error = iServer.ChangeEntry(entry, aOwnerId, aForcedUpdate, aBulk);

			if (error==KErrNone)

				{

				// switch the context of this object

				*iDescription = entry.iDescription;

				*iDetails = entry.iDetails;

				iEntry = entry;

				iEntry.iDescription.Set(*iDescription);

				iEntry.iDetails.Set(*iDetails);

				}

			}

		}

	// notify everyone of the change unless this is a bulk change.

	// for bulk changes (e.g. email synchronize, all notifications get handled elsewhere

	if ((error == KErrNone) && (!aBulk))

		{

		iServer.NotifyChanged(EMsvEntriesChanged, iEntry.Id(), iEntry.Parent());

		}

	return error;

	}

/**

Creates a new entry as a child of the current context.

The parent ID and entry ID are set by the Message Server.

@param	aEntry

Index entry value for the new entry

@return

KErrNone - success; KErrNoMemory - a memory allocation failed;

KErrNotSupported - aEntry is invalid

*/

EXPORT_C TInt CMsvServerEntry::CreateEntry(TMsvEntry& aEntry)

	{

	return CreateEntry(aEntry, KMsvServerId);

	}

/**

Creates a new entry as a child of the current context.

Ownership of the created entry is given to the process with the specified SID.

The parent ID and entry ID are set by the Message Server.

@param	aEntry

Index entry value for the new entry

@param	aOwnerId

The SID of the process that will own the create entry.

@return

KErrNone - success; KErrNoMemory - a memory allocation failed;

KErrNotSupported - aEntry is invalid

*/

EXPORT_C TInt CMsvServerEntry::CreateEntry(TMsvEntry& aEntry, TSecureId aOwnerId)

	{

	return CreateEntry(aEntry, aOwnerId, EFalse);

	}

/**

Creates a new entry as a child of the current context as part of a

bulk creation operation. The entry will not be committed to file immediately.

The parent ID and entry ID are set by the Message Server.

@param	aEntry

Index entry value for the new entry

@param	aOwnerId

The SID of the process that will own the create entry.

@return

KErrNone - success; KErrNoMemory - a memory allocation failed;

KErrNotSupported - aEntry is invalid

*/

EXPORT_C TInt CMsvServerEntry::CreateEntryBulk(TMsvEntry& aEntry, TSecureId aOwnerId)

	{

	return CreateEntry(aEntry, aOwnerId, ETrue);

	}

/**

Creates a new entry as a child of the current context as part of a

bulk creation operation

The parent ID and entry ID are set by the Message Server.

@param	aEntry

Index entry value for the new entry

@return

KErrNone - success; KErrNoMemory - a memory allocation failed;

KErrNotSupported - aEntry is invalid

*/

EXPORT_C TInt CMsvServerEntry::CreateEntryBulk(TMsvEntry& aEntry)

	{

	return CreateEntry(aEntry, KMsvServerId, ETrue);

	}

/**

Creates a new entry as a child of the current context.

Ownership of the created entry is given to the process with the specified SID.

The parent ID and entry ID are set by the Message Server.

@param	aEntry

Index entry value for the new entry

@param	aOwnerId

The SID of the process that will own the create entry.

@param aBulk

A boolean value to indicate whether this is part of a bulk operation. (ETrue = bulk)

@return

KErrNone - success; KErrNoMemory - a memory allocation failed;

KErrNotSupported - aEntry is invalid

*/

EXPORT_C TInt CMsvServerEntry::CreateEntry(TMsvEntry& aEntry, TSecureId aOwnerId, TBool aBulk)

	{

	__ASSERT_DEBUG(iEntry.Id()!=KMsvNullIndexEntryId, PanicServer(EMsvEntryWithNoContext2));

	aEntry.SetParent(iEntry.Id());

	__ASSERT_DEBUG(MsvUtils::ValidEntry(aEntry, ETrue), PanicServer(EMsvBadEntryContents));

	// if valid - try to create the new child

	TInt error;

	if (iEntry.Id()==KMsvNullIndexEntryId || !MsvUtils::ValidEntry(aEntry, ETrue))

		error = KErrNotSupported;

	else

		{

		error = iServer.AddEntry(aEntry, aOwnerId, ETrue, aBulk);

		// if the child was created,then notify everyone, otherwise reset the parent

		if (error)

			aEntry.SetParent(KMsvNullIndexEntryId);

		else

			{

			if (!aBulk)

				{

				iServer.NotifyChanged(EMsvEntriesCreated, aEntry.Id(), aEntry.Parent());

				}

			iEntry.SetOwner(ETrue);

			}

		}

	return error;

	}

EXPORT_C void CMsvServerEntry::CompleteBulk()

//

/** Completes the current bulk transaction (if any)

 Requests that the message server commit to the index file on disk

 any entries which have not been committed and to generate notifications

 for any entries which require them.

 @return void */

	{

	iServer.CompleteBulkTransaction();

	}

TBool CMsvServerEntry::AreChildren(const CMsvEntrySelection& aSelection) const

//

// Returns true if all the entries are children

//

	{

	TInt count = aSelection.Count();

	while (count--)

		{

		if (!IsAChild(aSelection.At(count)))

			{

			return EFalse;

			}

		}

	return ETrue;

	}

TBool CMsvServerEntry::IsAChild(TMsvId aId) const

//

//

//

	{

	TMsvEntry* entry=NULL;

	TInt err = KErrNone;

	err = iServer.IndexAdapter().GetEntry(aId, entry);

	if (err ==KErrNone && entry->Parent()==iEntry.Id())

		return ETrue;

	return EFalse;

	}

EXPORT_C TInt CMsvServerEntry::DeleteEntry(TMsvId aId)

//

// Deletes the child of the current context recursively.

//