--- /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<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
+