diff -r 000000000000 -r e686773b3f54 pimprotocols/phonebooksync/Server/SyncEngineRequest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimprotocols/phonebooksync/Server/SyncEngineRequest.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,307 @@ +// 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 templateIdAndBufferSizePckg(iWriteContactTemplateIdAndBufferSize); + TPckg 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(&iWriteContactTemplateIdAndBufferSize), + sizeof(RPhoneBookSession::TTemplateAndBufferSize)); + iWriteContactSlotNumberPtr.Set(reinterpret_cast(&iWriteContactSlotNumber), + sizeof(iWriteContactSlotNumber), sizeof(iWriteContactSlotNumber)); + iWriteContactPhoneBookIDPtr.Set(reinterpret_cast(&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 slotNumPckg(iWriteContactSlotNumber); + TPckg 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 +