// Copyright (c) 2005-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:
// The CSyncEngineRequest class is used to store and monitor a request which
// has, or will be, sent to the Background Sync Engine.
// 
//

/**
 @file
 @internalComponent
*/

#include "Phonebook.h"
#include "PhonebookManager.h"
#include "SyncContactICCEntry.h"
#include "phbksyncsvr.h"
#include "phbksynclog.h"
#include "SyncEngineSession.h"
#include "SyncEngineServer.h"
#include "phbksyncsess.h"
#include "SyncEngineRequest.h"
#include "common.h"


/**
 *  Static factory method used to create a CSyncEngineRequest object.
 *
 *  @param aServer                Reference to the front-end server.
 *  @param aSyncEngine            Handle to the background sync engine.
 *  @param aPhonebookSyncRequest  Type of engine sync request.
 *  @param aPhonebookUid          UID of the phonebook being operated on.
 *  @param aContactId             Contact ID of the entry being modified.
 *  @param aClientSession         Pointer to the client session (if one exists).
 *  @param aClientMessage         Reference to the client message (if one exists).
 *
 *  @return  Returns the pointer to a newly created CSyncEngineRequest object.
 */
CSyncEngineRequest*  CSyncEngineRequest::NewL(CPhoneBookServer& aServer,
									  RSyncEngineSession& aSyncEngine,
									  TPhonebookSyncRequest aPhonebookSyncRequest,
									  TUid aPhonebookUid,
									  TContactItemId aContactId,
									  CPhoneBookSession* aClientSession,
									  const RMessage2& aClientMessage)
	{
	CSyncEngineRequest*  engineRequest = new(ELeave) CSyncEngineRequest(aServer, aSyncEngine,
																aPhonebookSyncRequest,
																aPhonebookUid, aContactId,
																aClientSession, aClientMessage);
	CleanupStack::PushL(engineRequest);
	engineRequest->ConstructL();
	CleanupStack::Pop(engineRequest);

	return engineRequest;
	} // CActiveEngineRequest::NewL


/**
 *  Private constructor for an engine request.
 *
 *  @param aServer                Reference to the front-end server.
 *  @param aSyncEngine            Handle to the background sync engine.
 *  @param aPhonebookSyncRequest  Type of engine sync request.
 *  @param aPhonebookUid          UID of the phonebook being operated on.
 *  @param aContactId             Contact ID of the entry being modified.
 *  @param aClientSession         Pointer to the client session (if one exists).
 *  @param aClientMessage         Reference to the client message (if one exists).
 */
CSyncEngineRequest::CSyncEngineRequest(CPhoneBookServer& aServer,
							   RSyncEngineSession& aSyncEngine,
							   TPhonebookSyncRequest aPhonebookSyncRequest,
							   TUid aPhonebookUid,
							   TContactItemId aContactId,
							   CPhoneBookSession* aClientSession,
							   const RMessage2& aClientMessage)
  : CActive(EPriorityNormal),
    iServer(aServer),
    iSyncEngine(aSyncEngine),
    iPhonebookSyncRequest(aPhonebookSyncRequest),
    iPhonebookUid(aPhonebookUid),
    iContactId(aContactId),
    iClientSession(aClientSession),
    iClientMessage(aClientMessage),
    iWriteContactSlotNumber(-1),
    iWriteContactICCEntryBuf(NULL),
	iWriteContactTemplateIdAndBufferSizePtr(NULL, 0),
	iWriteContactSlotNumberPtr(NULL, 0),
	iWriteContactPhoneBookIDPtr(NULL, 0),
	iWriteContactICCEntryBufPtr(NULL, 0)
    {
	// NOP
	} // CSyncEngineRequest::CSyncEngineRequest


/**
 *  Destructor for the engine request.
 */
CSyncEngineRequest::~CSyncEngineRequest()
	{
	LOGACTIVE1(_L8("~CSyncEngineRequest()"));
	Cancel();
	
	delete iWriteContactICCEntryBuf;
	} // CSyncEngineRequest::~CSyncEngineRequest
	

/**
 *  Second phrase constructor for the engine request. The request will be initialised
 *  and any client side data will be stored for lating sending to the engine.
 */
void CSyncEngineRequest::ConstructL()
	{
	LOGACTIVE1(_L8("CSyncEngineRequest::ConstructL()"));

	//
	// Read any data required into the engine request's buffers...
	//
	if (iPhonebookSyncRequest == ESyncWriteCntToICC)
		{
		TPckg<RPhoneBookSession::TTemplateAndBufferSize>  templateIdAndBufferSizePckg(iWriteContactTemplateIdAndBufferSize);
		TPckg<TInt>  slotNumPckg(iWriteContactSlotNumber);

		iClientMessage.ReadL(0, templateIdAndBufferSizePckg); 
		iClientMessage.ReadL(1, slotNumPckg);

		iWriteContactICCEntryBuf = CBufFlat::NewL(1);
		iWriteContactICCEntryBuf->ResizeL(iWriteContactTemplateIdAndBufferSize.bufferSize); 
		iWriteContactICCEntryBufPtr.Set(iWriteContactICCEntryBuf->Ptr(0));
		iClientMessage.ReadL(3, iWriteContactICCEntryBufPtr);

		//
		// Call the engine's write contact function...
		//		
		iWriteContactTemplateIdAndBufferSizePtr.Set(reinterpret_cast<const TText8*>(&iWriteContactTemplateIdAndBufferSize),
													sizeof(RPhoneBookSession::TTemplateAndBufferSize));
		iWriteContactSlotNumberPtr.Set(reinterpret_cast<TText8*>(&iWriteContactSlotNumber),
									   sizeof(iWriteContactSlotNumber), sizeof(iWriteContactSlotNumber));
		iWriteContactPhoneBookIDPtr.Set(reinterpret_cast<TText8*>(&iPhonebookUid),
										sizeof(iPhonebookUid), sizeof(iPhonebookUid));		
		iWriteContactICCEntryBufPtr.Set(iWriteContactICCEntryBuf->Ptr(0));
		}

	CActiveScheduler::Add(this);
	} // CSyncEngineRequest::ConstructL


/**
 *  This function is used to issue a request to the Background Sync Engine via the
 *  Sync Engine Session. Once this function completes the request will be active and
 *  when the request is completed, RunL() will be called.
 */
void CSyncEngineRequest::StartRequest()
	{
	LOGACTIVE1(_L8("CSyncEngineRequest::StartRequest()"));

	if (iPhonebookSyncRequest == ESyncDoSynchronisation)
		{
		iSyncEngine.DoSynchronisation(iStatus, iPhonebookUid);
		SetActive();
		}
	else if (iPhonebookSyncRequest == ESyncDeleteCntFromICC)
		{
		iSyncEngine.DeleteContact(iStatus, iPhonebookUid, iContactId);
		SetActive();
		}
	else if (iPhonebookSyncRequest == ESyncWriteCntToICC)
		{
		iSyncEngine.WriteContact(iStatus,
								 iWriteContactTemplateIdAndBufferSizePtr,
								 iWriteContactSlotNumberPtr,
								 iWriteContactPhoneBookIDPtr,
								 iWriteContactICCEntryBufPtr);
		SetActive();
		}
	else
		{
		PhBkSyncPanic(EPhBkSyncPanicInvalidEngineRequest);
		}
	} // CSyncEngineRequest::StartRequest


/**
 *  Completes the clients request. This may involve performing additional
 *  actions such as informing the front-end server of status changes, or
 *  relaying information from the engine to the client.
 *
 *  The client request will be completed (if one exists) and this request
 *  will be completed (e.g. removed from the queue and deleted).
 */
void CSyncEngineRequest::CompleteClientRequestL()
	{
	LOGACTIVE1(_L8("CSyncEngineRequest::CompleteClientRequestL()"));

	//
	// Perform any special tasks for this request...
	//
	if (iPhonebookSyncRequest == ESyncDoSynchronisation)
		{
		//
		// Let the server know that the cache state has changed...
		//
		iServer.CompleteNotifyStateChange(iPhonebookUid);
		}
	else if (iStatus.Int() == KErrNone  &&
			 iPhonebookSyncRequest == ESyncWriteCntToICC)
		{
		//
		// Pass back the slot number and phonebook which may have been
		// updated (in the cases where the slot or phonebook was not)
		// specified.
		//
		TPckg<TInt>  slotNumPckg(iWriteContactSlotNumber);
		TPckg<TUid>  phonebookUidPckg(iPhonebookUid);

		iClientMessage.WriteL(1, slotNumPckg);
		iClientMessage.WriteL(2, phonebookUidPckg);
		}

	//
	// Complete the client's request (if one exists)...
	//
	if (iClientSession != NULL)
		{
		iClientSession->CompleteRequest(iClientMessage, iStatus.Int());
		}

	//
	// Remove this request from the request queue and start the next request...
	//
	iServer.CompleteEngineRequest(*this);
	
	//
	// Delete this request...
	//
	delete this;
	} // CSyncEngineRequest::CompleteClientRequestL


/**
 *  Standard Active Object RunL() method. This completes the client request.
 */
void CSyncEngineRequest::RunL()
	{
	LOGACTIVE1(_L8("CSyncEngineRequest::RunL()"));

	CompleteClientRequestL();
	} // CSyncEngineRequest::RunL


/** 
 *  Standard Active Object DoCancel method. This is called when the Cancel()
 *  method is called on an active request. It cancels the pending request
 *  with the Background Sync Engine.
 */
void CSyncEngineRequest::DoCancel()
	{
	if (iPhonebookSyncRequest == ESyncDoSynchronisation)
		{
		iSyncEngine.DoSynchronisationCancel(iPhonebookUid);
		}
	else if (iPhonebookSyncRequest == ESyncDeleteCntFromICC)
		{
		iSyncEngine.DeleteContactCancel(iPhonebookUid);
		}
	else if (iPhonebookSyncRequest == ESyncWriteCntToICC)
		{
		iSyncEngine.WriteContactCancel(iPhonebookUid);
		}
	else
		{
		iStatus = KErrCancel;
		}
	} // CSyncEngineRequest::DoCancel


/**
 *  Standard Active Object RunError() method. This is called if the RunL()
 *  method leaves. Hopefully this should not happen.
 *
 *  @param aError  Leave code from the RunL().
 *
 *  @return KErrNone (although the code will panic first).
 */
TInt CSyncEngineRequest::RunError(TInt aError)
	{
#ifdef _DEBUG
	LOGACTIVE2(_L8("CSyncEngineRequest::RunError(%d)"), aError);
#else
	(void) aError;
#endif

	PhBkSyncPanic(EPhBkSyncPanicUnexpectedLeave);

	return KErrNone;	
	} // CSyncEngineRequest::RunError