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

// Contains method implementations for CPhonebookSession.

// 

//

/**

 @file

 @internalComponent

*/

#include "Phonebook.h"

#include "PhonebookManager.h"

#include "SyncContactICCEntry.h"

#include "phbksyncsvr.h"

#include "phbksyncsess.h"

#include "phbksynclog.h"

#ifdef _DEBUG

/**

 *  Debug text names for the Phonebook Sync IPC Requests.

 */

const char*  KPhonebookSyncRequestNames[26] = {

		"ESyncDoSynchronisation", "ESyncGetContactFormat", "ESyncGetSyncMode",

		"ESyncSetSyncMode", "ESyncDeleteCntFromICC", "ESyncWriteCntToICC",

		"ESyncValidateContact", "ESyncUpdateLookupTable",

		"ESyncGetPhoneBookId", "ESyncGetCacheState", "ESyncDbgMarkHeap",

		"ESyncDbgCheckHeap", "ESyncDbgMarkEnd", "ESyncDbgFailNext",

		"ESyncDoSynchronisationCancel", "ESyncDeleteCntFromICCCancel",

		"ESyncWriteCntToICCCancel", "ESyncNotifyCacheStateChange",

		"ESyncNotifyCacheStateChangeCancel", "ESyncGetLastSyncError",

		"ESyncGetNumSlots", "ESyncGetNumFreeSlots", "ESyncGetFreeSlots",

		"ESyncGetSlotId", "ESyncFlushInterfaceQueue", "ESyncShutdownServer"};

#endif

/**

 *  Second phase constructor for sessions. Called by the CServer2 framework

 *  when a session is created (e.g. a connection is made to the server).

 */

void CPhoneBookSession::CreateL()

	{

	LOGSESSION1(_L8("CreateL()"));

	Server().AddSessionL(this);

	} // CPhoneBookSession::CreateL()

/**

 *  Destructor for session classes. When this is called it indicates that

 *  a session is closing its connection with the server.

 */

CPhoneBookSession::~CPhoneBookSession()

	{

	LOGSESSION1(_L8("~CPhoneBookSession()"));

	Server().DropSession(this);

	} // CPhoneBookSession::~CPhoneBookSession()

/**

 *  Handle message requests for this session. Leaving is handled by

 *  CPhoneBookServer::RunError() which reports the error code to the client.

 *

 *  @param aMessage  RMessage2 reference which encapsulates a client request.

 */

void CPhoneBookSession::ServiceL(const RMessage2& aMessage)

	{

	LOGSESSION4(_L8("ServiceL(): Session=0x%08x IPC=%d (%s)"),

	           this, aMessage.Function(),

	           KPhonebookSyncRequestNames[aMessage.Function()]);

	LOGSESSIONTIMESTAMP();

	switch (aMessage.Function())

		{

		case ESyncDoSynchronisation:

			{

			DoSynchronisationL(aMessage);

			}

			break;

		case ESyncGetContactFormat:

			{

			GetContactFormatL(aMessage);

			}

			break;

		case ESyncGetSyncMode:

			{

			GetSyncModeL(aMessage);

			}

			break;

		case ESyncSetSyncMode:

			{

			SetSyncModeL(aMessage);

			}

			break;

		case ESyncDeleteCntFromICC:

			{

			DeleteCntFromICCL(aMessage);

			}

			break;

		case ESyncWriteCntToICC:

			{

			WriteCntToICCL(aMessage);

			}

			break;

		case ESyncValidateContact:

			{

			ValidateContactL(aMessage);

			}

			break;

		case ESyncUpdateLookupTable:

			{

			UpdateLookupTableL(aMessage);

			}

			break;

		case ESyncGetPhoneBookId:

			{

			GetPhoneBookIdL(aMessage);

			}

			break;

		case ESyncGetCacheState:

			{

			GetCacheStateL(aMessage);

			}

			break;

		case ESyncDbgMarkHeap:

			{

			DbgMarkHeapL(aMessage);

			}

			break;

		case ESyncDbgCheckHeap:

			{

			DbgCheckHeapL(aMessage);

			}

			break;

		case ESyncDbgMarkEnd:

			{

			DbgMarkEndL(aMessage);

			}

			break;

		case ESyncDbgFailNext:

			{

			DbgFailNextL(aMessage);

			}

			break;

		case ESyncDoSynchronisationCancel:

			{

			DoSynchronisationCancelL(aMessage);

			}

			break;

		case ESyncDeleteCntFromICCCancel:

			{

			DeleteCntFromICCCancelL(aMessage);

			}

			break;

		case ESyncWriteCntToICCCancel:

			{

			WriteCntToICCCancelL(aMessage);

			}

			break;

		case ESyncNotifyCacheStateChange:

			{

			NotifyCacheStateChangeL(aMessage);

			}

			break;

		case ESyncNotifyCacheStateChangeCancel:

			{

			NotifyCacheStateChangeCancelL(aMessage);

			}

			break;

		case ESyncGetLastSyncError:

			{

			GetLastSyncErrorL(aMessage);

			}

			break;

		case ESyncGetNumSlots:

			{

			GetNumSlotsL(aMessage);

			}

			break;

		case ESyncGetNumFreeSlots:

			{

			GetNumFreeSlotsL(aMessage);

			}

			break;

		case ESyncGetFreeSlots:

			{

			GetFreeSlotsL(aMessage);

			}

			break;

		case ESyncGetSlotId:

			{

			GetSlotIdL(aMessage);

			}

			break;

		case ESyncFlushInterfaceQueue:

			{

			CompleteRequest(aMessage, KErrNone);

			}

			break;

		case ESyncShutdownServer:

			{

			ShutdownServerL(aMessage);

			}

			break;

		default:

			{

			aMessage.Panic(PHBKSYNC_SERVER_NAME,

						   EPhBkSyncPanicIllegalFunction);

			}

			break;

		}

	} // CPhoneBookSession::ServiceL()

/**

 *  Completes a client request. This function provides a single point of

 *  message completion which benefits debugging and maintenance.

 *

 *  @param aMessage  The RMessage2 client request.

 *  @param aResult   Result of the request.

 */

void CPhoneBookSession::CompleteRequest(const RMessage2& aMessage,

										TInt aResult) const

	{

	LOGSESSION5(_L8("CompleteRequest(): Session=0x%08x "

					"IPC=%d (%s) Result=%d"), this, aMessage.Function(),

	           KPhonebookSyncRequestNames[aMessage.Function()], aResult);

	LOGSESSIONTIMESTAMP();

	if (aMessage.IsNull() == EFalse)

		{

	    aMessage.Complete(aResult);

		}

    } // CPhoneBookSession::CompleteRequest()

/**

 *  Requests a synchronisation from the server. This is an asynchronous

 *  request.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::DoSynchronisationL(const RMessage2& aMessage)

	{

	TUid  phonebookUid = TUid::Uid(aMessage.Int0());

	Server().DoSynchronisationL(*this, aMessage, phonebookUid);

	} // CPhoneBookSession::DoSynchronisationL()

/**

 *  Requests the supported phonebook field formats from the server. This is a

 *  synchronous request which will be completed when the procedure returns.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::GetContactFormatL(const RMessage2& aMessage)

	{

	TUid  phonebookUid = TUid::Uid(aMessage.Int0());

	//

	// Get the contact format from the server...

	//

	RPhoneBookSession::TContactFieldsV3  contactFieldsV3;

	TInt  result;

	result = Server().GetContactFormatL(phonebookUid, contactFieldsV3);

	//

	// If the contact format was retrieved from the server, then write it to

	// the client.

	//

	if (result == KErrNone)

		{

		RPhoneBookSession::TContactFieldsV1::TContactFieldsExtensionId  extensionId;

		extensionId = static_cast<RPhoneBookSession::TContactFieldsV1::TContactFieldsExtensionId>(aMessage.Int1());

		if (extensionId == RPhoneBookSession::TContactFieldsV1::KPhBkSyncTContactFieldsV1)

			{

			RPhoneBookSession::TContactFieldsV1  contactFieldsV1;

			RPhoneBookSession::TContactFieldsV1Pckg  contactFieldsV1Pckg(contactFieldsV1);

			contactFieldsV1 = static_cast<RPhoneBookSession::TContactFieldsV1>(contactFieldsV3);

			aMessage.WriteL(2, contactFieldsV1Pckg);

			}

		else if (extensionId == RPhoneBookSession::TContactFieldsV1::KPhBkSyncTContactFieldsV2)

			{

			RPhoneBookSession::TContactFieldsV2  contactFieldsV2;

			RPhoneBookSession::TContactFieldsV2Pckg  contactFieldsV2Pckg(contactFieldsV2);

			contactFieldsV2 = static_cast<RPhoneBookSession::TContactFieldsV2>(contactFieldsV3);

			aMessage.WriteL(2, contactFieldsV2Pckg);

			}

		else

			{

			RPhoneBookSession::TContactFieldsV3Pckg  contactFieldsV3Pckg(contactFieldsV3);

			aMessage.WriteL(2, contactFieldsV3Pckg);

			}

		}

	//

	// Complete the request...

	//

	CompleteRequest(aMessage, result);

	} // CPhoneBookSession::GetContactFormatL()

/**

 *  Requests the current setting for the Synchronisation Mode from the server.

 *  This is a synchronous request which will be completed when the procedure

 *  returns.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::GetSyncModeL(const RMessage2& aMessage)

	{

	TUid  phonebookUid = TUid::Uid(aMessage.Int0());

	//

	// Get the sync mode from the server...

	//

	RPhoneBookSession::TPhonebookSyncMode  syncMode;

	TInt  result;

	result = Server().GetSyncModeL(phonebookUid, syncMode);

	//

	// If the sync mode was retrieved then write it back to the client.

	//

	if (result == KErrNone)

		{

		TPckg<RPhoneBookSession::TPhonebookSyncMode>  syncModePckg(syncMode);

		aMessage.WriteL(1, syncModePckg);

		}

	//

	// Complete the request...

	//

	CompleteRequest(aMessage, result);

	} // CPhoneBookSession::GetSyncModeL()

/**

 *  Requests the server to set the sync mode. This is a synchronous request

 *  which will be completed when the procedure returns.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::SetSyncModeL(const RMessage2& aMessage)

	{

	TUid  phonebookUid = TUid::Uid(aMessage.Int0());

	//

	// Set the sync mode via the server...

	//

	RPhoneBookSession::TPhonebookSyncMode  syncMode = static_cast<RPhoneBookSession::TPhonebookSyncMode>(aMessage.Int1());

	TInt  result;

	result = Server().SetSyncModeL(phonebookUid, syncMode);

	//

	// Complete the request...

	//

	CompleteRequest(aMessage, result);

	} // CPhoneBookSession::SetSyncModeL()

/**

 *  Requests the server to delete a contact from the ICC. This is an

 *  asynchronous request.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::DeleteCntFromICCL(const RMessage2& aMessage)

	{

	TContactItemId  contactItemId = aMessage.Int0();

	Server().DeleteCntFromICCL(*this, aMessage, contactItemId);

	} // CPhoneBookSession::DeleteCntFromICCL()

/**

 *  Requests the server to write a contact to the ICC. This is an asynchronous

 *  request.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::WriteCntToICCL(const RMessage2& aMessage)

	{

	//	

	// Extract the request parameters from aMessage. These are the template ID,

	// buffer size, slot number and ICC Entry pointer.

	//

	RPhoneBookSession::TTemplateAndBufferSize  templateIdAndBufferSize;

	TInt  slotNum;

	TPtr8 iccEntryPtr(NULL, 0);

	TPckg<RPhoneBookSession::TTemplateAndBufferSize>  templateIdAndBufferSizePckg(templateIdAndBufferSize);

	TPckg<TInt>  slotNumPckg(slotNum);

	aMessage.ReadL(0, templateIdAndBufferSizePckg); 

	aMessage.ReadL(1, slotNumPckg);

	//

	// Pass the request to the server for further processing.

	//

	Server().WriteCntToICCL(*this, aMessage, slotNum,

	                        templateIdAndBufferSize.templateId);

	} // CPhoneBookSession::WriteCntToICCL()

/**

 *  Requests the server to validate a contact. This is an asynchronous

 *  request.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::ValidateContactL(const RMessage2& aMessage)

	{

	TContactItemId  contactItemId = aMessage.Int0();

	MContactSynchroniser::TValidateOperation  validateOp = static_cast<MContactSynchroniser::TValidateOperation>(aMessage.Int1());

	TInt  result;

	result = Server().ValidateContactL(contactItemId, validateOp);

	//

	// Complete the request...

	//

	CompleteRequest(aMessage, result);

	} // CPhoneBookSession::ValidateContactL()

/**

 *  Requests the server to update its Look Up Table with new contact

 *  information. This is a synchronous request which will be completed when

 *  the procedure returns.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::UpdateLookupTableL(const RMessage2& aMessage)

	{

	TUid  phonebookUid = TUid::Uid(aMessage.Int0());

	TContactItemId  contactItemId = aMessage.Int1();

	TInt  index = aMessage.Int2();

	TInt  result;

	result = Server().UpdateLookupTableL(phonebookUid, contactItemId, index);

	//

	// Complete the request...

	//

	CompleteRequest(aMessage, result);

	} // CPhoneBookSession::UpdateLookupTableL()

/**

 *  Requests the Phonebook template or group ID from the server for a

 *  particular phonebook. This is a synchronous request which will be

 *  completed when the procedure returns.

 *

 *  @param aMessage  RMessage2 client request.

 */

void CPhoneBookSession::GetPhoneBookIdL(const RMessage2& aMessage)

	{

	TUid  phonebookUid = TUid::Uid(aMessage.Int0());

	RPhoneBookSession::TSyncIdType  syncIdType = static_cast<RPhoneBookSession::TSyncIdType>(aMessage.Int1());

	TContactItemId  contactItemId;

	TInt  result;

	result = Server().GetPhoneBookIdL(phonebookUid, syncIdType, contactItemId);

	//

	// If the phonebook ID was retrieved then write it back to the client.

	//

	if (result == KErrNone)

		{

		TPckg<TContactItemId>  contactItemIdPckg(contactItemId);

		aMessage.WriteL(2, contactItemIdPckg);

		}

	//

	// Complete the request...

	//

	CompleteRequest(aMessage, result);

	} // CPhoneBookSession::GetPhoneBookIdL()