// 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:
// Implementation of the Background Sync Engine session class. This class is
// responsible for passing the requests that have come from the main
// front-end server's engine handle to the main engine class.
// 
//

/**
 @file
 @internalComponent
*/

#include "Phonebook.h"
#include "PhonebookManager.h"
#include "SyncContactICCEntry.h"
#include "SyncEngineServer.h"
#include "SyncEngineSession.h"
#include "phbksynclog.h"


#ifdef _DEBUG
/**
 *  Debug text names to the Phonebook Sync IPC Requests.
 */
const char*  KEnginePhonebookSyncRequestNames[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 construct for sessions. Called by the CServer2 framework
 *  when a session is created (e.g. a connection is made to the server).
 */
void CSyncEngineSession::CreateL()
	{
	LOGENGINE1(_L8("CreateL()"));

	Server().AddSessionL(this);
	} // CSyncEngineSession::CreateL()


/**
 *  Destructor from session classes. When this is called it indicates that
 *  a session is closing its connection with the server.
 */
CSyncEngineSession::~CSyncEngineSession()
	{
	LOGENGINE1(_L8("~CSyncEngineSession()"));

	Server().DropSession(this);
	} // CSyncEngineSession::~CSyncEngineSession()


/**
 *  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 CSyncEngineSession::ServiceL(const RMessage2& aMessage)

	{
	LOGENGINE4(_L8("ServiceL(): Session=0x%08x IPC=%d (%s)"),
	           this, aMessage.Function(),
	           KEnginePhonebookSyncRequestNames[aMessage.Function()]);
	LOGENGINETIMESTAMP();
	
	switch (aMessage.Function())
		{
		case ESyncDoSynchronisation:
			{
			DoSynchronisationL(aMessage);
			}
			break;

		case ESyncDeleteCntFromICC:
			{
			DeleteCntFromICCL(aMessage);
			}
			break;

		case ESyncWriteCntToICC:
			{
			WriteCntToICCL(aMessage);
			}
			break;

		case ESyncDoSynchronisationCancel:
			{
			DoSynchronisationCancelL(aMessage);
			}
			break;

		case ESyncDeleteCntFromICCCancel:
			{
			DeleteCntFromICCCancelL(aMessage);
			}
			break;

		case ESyncWriteCntToICCCancel:
			{
			WriteCntToICCCancelL(aMessage);
			}
			break;

		default:
			{
			CompleteRequest(aMessage, KErrNotSupported);
			}
			break;
		}
	} // CSyncEngineSession::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 CSyncEngineSession::CompleteRequest(const RMessage2& aMessage,
										TInt aResult) const
	{
	LOGENGINE5(_L8("CSyncEngineSession::CompleteRequest: Session=0x%08x "
					"IPC=%d (%s) Result=%d"), this, aMessage.Function(),
	           KEnginePhonebookSyncRequestNames[aMessage.Function()], aResult);
	LOGENGINETIMESTAMP();

	if (aMessage.IsNull() == EFalse)
		{
	    aMessage.Complete(aResult);
		}
    } // CSyncEngineSession::CompleteRequest()


/**
 *  Requests a synchronisation from the server. This is an asynchronous
 *  request.
 *
 *  @param aMessage  RMessage2 client request.
 */
void CSyncEngineSession::DoSynchronisationL(const RMessage2& aMessage)
	{
	TUid  phonebookUid = TUid::Uid(aMessage.Int0());

	Server().DoSynchronisationL(aMessage, phonebookUid);
	} // CSyncEngineSession::DoSynchronisationL()


/**
 *  Requests the server to delete a contact from the ICC. This is an
 *  asynchronous request.
 *
 *  @param aMessage  RMessage2 client request.
 */
void CSyncEngineSession::DeleteCntFromICCL(const RMessage2& aMessage)
	{
	TUid  phonebookUid = TUid::Uid(aMessage.Int0());
	TContactItemId  contactItemId = aMessage.Int1();
	
	Server().DeleteCntFromICCL(aMessage, phonebookUid, contactItemId);
	} // CSyncEngineSession::DeleteCntFromICCL()


/**
 *  Requests the server to write a contact to the ICC. This is an asynchronous
 *  request.
 *
 *  @param aMessage  RMessage2 client request.
 */
void CSyncEngineSession::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;
	TPtr8 iccEntryPtr(NULL, 0);
	TPckg<RPhoneBookSession::TTemplateAndBufferSize>  templateIdAndBufferSizePckg(templateIdAndBufferSize);

	aMessage.ReadL(0, templateIdAndBufferSizePckg); 

	//
	// Pass the request to the server for further processing.
	//
	Server().WriteCntToICCL(aMessage, templateIdAndBufferSize.templateId,
	                        templateIdAndBufferSize.bufferSize);
	} // CSyncEngineSession::WriteCntToICCL()


/**
 *  Requests the server to cancel a previous synchronisation request.
 *  This is a synchronous request which will be completed when the procedure
 *  returns.
 *
 *  @param aMessage  RMessage2 client request.
 */
void CSyncEngineSession::DoSynchronisationCancelL(const RMessage2& aMessage)
	{
	TUid  phonebookUid = TUid::Uid(aMessage.Int0());
	TInt  result;
	
	result = Server().DoSynchronisationCancelL(phonebookUid);

	//
	// Complete the request...
	//
	CompleteRequest(aMessage, result);
	} // CSyncEngineSession::DoSynchronisationCancelL()


/**
 *  Requests the server to cancel a previous delete contact request.
 *  This is a synchronous request which will be completed when the procedure
 *  returns.
 *
 *  @param aMessage  RMessage2 client request.
 */
void CSyncEngineSession::DeleteCntFromICCCancelL(const RMessage2& aMessage)
	{
	TUid  phonebookUid = TUid::Uid(aMessage.Int0());
	TInt  result;
	
	result = Server().DeleteCntFromICCCancelL(phonebookUid);

	//
	// Complete the request...
	//
	CompleteRequest(aMessage, result);
	} // CSyncEngineSession::DeleteCntFromICCCancelL()


/**
 *  Requests the server to cancel a previous write contact request.
 *  This is a synchronous request which will be completed when the procedure
 *  returns.
 *
 *  @param aMessage  RMessage2 client request.
 */
void CSyncEngineSession::WriteCntToICCCancelL(const RMessage2& aMessage)
	{
	TUid  phonebookUid = TUid::Uid(aMessage.Int0());
	TInt  result;
	
	result = Server().WriteCntToICCCancelL(phonebookUid);

	//
	// Complete the request...
	//
	CompleteRequest(aMessage, result);
	} // CSyncEngineSession::WriteCntToICCCancelL()