--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/pimprotocols/phonebooksync/Server/SyncEngineClient.cpp Tue Feb 02 10:12:17 2010 +0200
@@ -0,0 +1,381 @@
+// 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 client interface.
+//
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+#include "SyncEngineClient.h"
+#include "common.h"
+#include "Phonebook.h"
+#include "PhonebookManager.h"
+#include "SyncContactICCEntry.h"
+#include "SyncEngineServer.h"
+#include "phbksynclog.h"
+
+
+/**
+ * Size of the Background Sync Engine thread stack size.
+ */
+const TInt KSyncEngineStackSize(0x3000);
+
+
+/**
+ * Performs all server initialisation, in particular creation of the
+ * scheduler object, the enigne server and then runs the scheduler
+ * (which starts the engine server).
+ *
+ * @param aPhoneBookManager Reference to the phonebook manager class used
+ * by the front-end server.
+ */
+static void RunEngineL(CPhoneBookManager& aPhoneBookManager)
+ {
+ LOGENGINE1(_L8("RunEngineL()"));
+
+ //
+ // Create a new Sync Engine Server...
+ //
+ CSyncEngineServer* engine = CSyncEngineServer::NewL(aPhoneBookManager);
+ CleanupStack::PushL(engine);
+
+ //
+ // Initialisation complete, now signal the client thread...
+ //
+ LOGENGINE1(_L8("RunEngineL(): Meeting Rendezvous..."));
+ RThread::Rendezvous(KErrNone);
+
+ //
+ // Run the server...
+ //
+ LOGENGINE1(_L8("RunEngineL(): Starting server..."));
+ CSyncEngineScheduler::Start();
+
+ CleanupStack::PopAndDestroy(engine);
+ } // RunEngineL
+
+
+/**
+ * Thread function for starting the engine. This function basically just
+ * installs an Active Scheduler, a clean up stack and then calls the
+ * RunEngineL() leaving function.
+ *
+ * @param aPtr TAny pointer to the phonebook manager class used
+ * by the front-end server.
+ */
+static TInt RunEngineThread(TAny* aPtr)
+ {
+ CPhoneBookManager* phonebookManager = static_cast<CPhoneBookManager*>(aPtr);
+
+ LOGENGINE1(_L8("RunEngineThread()"));
+
+ //
+ // Create an Active Scheduler...
+ //
+ CActiveScheduler* scheduler = new CActiveScheduler();
+ if (scheduler == NULL)
+ {
+ return KErrNoMemory;
+ }
+ CActiveScheduler::Install(scheduler);
+
+ //
+ // Create a clean up stack...
+ //
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+
+ TRAPD(leaveCode, RunEngineL(*phonebookManager));
+
+ delete cleanup;
+ delete scheduler;
+
+ return leaveCode;
+ } // RunEngineThread
+
+
+/**
+ * Start the engine thread.
+ */
+TInt RSyncEngineSession::StartPhBkSyncEngine(CPhoneBookManager* aPhoneBookManager)
+ {
+ LOGENGINE1(_L8("RSyncEngineSession::StartPhBkSyncEngine()"));
+
+ //
+ // Create the Sync Engine Thread (using the same heap as this thread) at
+ // EPriorityAbsoluteBackground priority, ...
+ //
+ TInt ret;
+
+ ret = iEngineThread.Create(PHBKSYNC_ENGINE_NAME, RunEngineThread,
+ KSyncEngineStackSize, NULL, aPhoneBookManager);
+ if (ret != KErrNone)
+ {
+ return ret;
+ }
+
+ iEngineThread.SetPriority(EPriorityAbsoluteBackground);
+
+ //
+ // Logon to the engine thread. This will be used later to ensure the
+ // thread shuts down when closed.
+ //
+ iEngineThread.Logon(iEngineThreadStatus);
+ if (iEngineThreadStatus != KRequestPending)
+ {
+ iEngineThread.Kill(0);
+ iEngineThread.Close();
+
+ User::WaitForRequest(iEngineThreadStatus);
+
+ return iEngineThreadStatus.Int();
+ }
+
+ //
+ // Rendezvous with the engine or abort the engine start...
+ //
+ TRequestStatus rendezvousStatus;
+
+ iEngineThread.Rendezvous(rendezvousStatus);
+ if (rendezvousStatus != KRequestPending)
+ {
+ iEngineThread.Kill(0);
+ iEngineThread.Close();
+
+ User::WaitForRequest(rendezvousStatus);
+ User::WaitForRequest(iEngineThreadStatus);
+
+ return rendezvousStatus.Int();
+ }
+
+ //
+ // The thread is ready to go...
+ //
+ iEngineThread.Resume();
+ User::WaitForRequest(rendezvousStatus);
+ if (rendezvousStatus != KErrNone)
+ {
+ iEngineThread.Kill(0);
+ iEngineThread.Close();
+
+ User::WaitForRequest(iEngineThreadStatus);
+
+ return rendezvousStatus.Int();
+ }
+
+ return KErrNone;
+ } // RSyncEngineSession::StartPhBkSyncEngine
+
+
+/**
+ * Standard constructor.
+ */
+RSyncEngineSession::RSyncEngineSession()
+ {
+ iEngineThread.SetHandle(0);
+ } // RSyncEngineSession::RSyncEngineSession
+
+
+/**
+ * Connects the client to the Phonebook Synchronizer Server.
+ *
+ * This must be used before any of the other methods listed in
+ * this API section. The first client to call this method will
+ * cause the initiation of the Phonebook Synchronizer Server
+ * within its own executable process.
+ *
+ * @param aPhoneBookManager Pointer to the phonebook manager class used
+ * by the front-end server.
+ *
+ * @return KErrNone if successful, a system-wide error code if not.
+ *
+ * @capability None
+ */
+TInt RSyncEngineSession::Connect(CPhoneBookManager* aPhoneBookManager)
+ {
+ LOGENGINE1(_L8("RSyncEngineSession::Connect()"));
+
+ //
+ // Create a session with the server, but if it doesn't exist then start it and
+ // then create a session.
+ //
+ TInt result = CreateSession(PHBKSYNC_ENGINE_NAME, TVersion());
+ if (result == KErrNotFound || result == KErrServerTerminated)
+ {
+ result = StartPhBkSyncEngine(aPhoneBookManager);
+
+ if(result == KErrNone)
+ {
+ result = CreateSession(PHBKSYNC_ENGINE_NAME, TVersion());
+ }
+ }
+
+ //
+ // If the creation of the session fails then close it to clean up
+ // any allocated member data or running threads...
+ //
+ if (result != KErrNone)
+ {
+ Close();
+ }
+
+ return result;
+ } // RSyncEngineSession::Connect
+
+
+/**
+ * Closes the client's session with the Phonebook Synchronizer Server.
+ *
+ * @capability None
+ */
+void RSyncEngineSession::Close()
+ {
+ LOGENGINE1(_L8("RSyncEngineSession::Close()"));
+
+ RSessionBase::Close();
+
+ //
+ // Ensure the engine thread shuts down before we return...
+ //
+ if (iEngineThread.Handle() != 0)
+ {
+ User::WaitForRequest(iEngineThreadStatus);
+ iEngineThread.Close();
+ }
+ } // RSyncEngineSession::Close
+
+
+/**
+ * Instructs the engine to start a manual synchronisation of the ICC
+ * phonebook specified by the aPhonebookUid parameter.
+ *
+ * @param aReqStatus On completion, KErrNone if successful, a
+ * system-wide error code if not.
+ * @param aPhonebookUid TUid of the ICC phonebook to be synchronised.
+ *
+ * @capability ReadUserData
+ * @capability WriteUserData
+ */
+void RSyncEngineSession::DoSynchronisation(TRequestStatus& aReqStatus,
+ TUid aPhonebookUid)
+ {
+ LOGENGINE2(_L8("RSyncEngineSession::DoSynchronisation(): 0x%08x"),
+ aPhonebookUid);
+
+ SendReceive(ESyncDoSynchronisation, TIpcArgs(aPhonebookUid.iUid), aReqStatus);
+ } // RSyncEngineSession::DoSynchronisation
+
+
+/**
+ * Cancels an existing Syncronisation request.
+ *
+ * @param aPhonebookUid TUid of the ICC phonebook to cancel.
+ *
+ * @capability ReadUserData
+ * @capability WriteUserData
+ */
+void RSyncEngineSession::DoSynchronisationCancel(TUid aPhonebookUid)
+ {
+ LOGENGINE2(_L8("RSyncEngineSession::DoSynchronisationCancel(): 0x%08x"),
+ aPhonebookUid);
+
+ SendReceive(ESyncDoSynchronisationCancel, TIpcArgs(aPhonebookUid.iUid));
+ } // RSyncEngineSession::DoSynchronisationCancel
+
+
+/**
+ * Write the contact item to an ICC phonebook. The parameters for this
+ * function are left in the original packaged state from the front-end
+ * server's client.
+ *
+ * @param aReqStatus On completion, KErrNone if successful,
+ * a system-wide error code if not.
+ * @param aTemplateIdAndBufferSizePtr Packaged pointer to the template and
+ * buffer size.
+ * @param aSlotNumberPtr Packaged pointer to the slot number.
+ * @param aPhoneBookUidPtr Packaged pointer to the phonebook UID.
+ * @param aICCEntryBufPtr Packaged pointer to the ICC Entry.
+ *
+ * @capability WriteUserData
+ */
+void RSyncEngineSession::WriteContact(TRequestStatus& aReqStatus,
+ TPtrC8& aTemplateIdAndBufferSizePtr,
+ TPtr8& aSlotNumberPtr,
+ TPtr8& aPhoneBookUidPtr,
+ TPtr8& aICCEntryBufPtr)
+ {
+ LOGENGINE1(_L8("RSyncEngineSession::WriteContact()"));
+
+ TIpcArgs args(&aTemplateIdAndBufferSizePtr, &aSlotNumberPtr,
+ &aPhoneBookUidPtr, &aICCEntryBufPtr);
+
+ SendReceive(ESyncWriteCntToICC, args, aReqStatus);
+ } // RSyncEngineSession::WriteContact
+
+
+/**
+ * Cancels an existing WriteContact request.
+ *
+ * @param aPhonebookUid TUid of the ICC phonebook to cancel.
+ *
+ * @capability WriteUserData
+ */
+void RSyncEngineSession::WriteContactCancel(TUid aPhonebookUid)
+ {
+ LOGENGINE2(_L8("RSyncEngineSession::WriteContactCancel(): 0x%08x"),
+ aPhonebookUid);
+
+ SendReceive(ESyncWriteCntToICCCancel, TIpcArgs(aPhonebookUid.iUid));
+ } // RSyncEngineSession::WriteContactCancel
+
+
+/**
+ * Deletes a contact item from the ICC.
+ *
+ * @param aReqStatus On completion, KErrNone if successful, a system-wide
+ * error code if not.
+ * @param aPhonebookUid UID of the ICC phonebook to delete from.
+ * @param aId The contact item to delete.
+ *
+ * @capability WriteUserData
+ */
+void RSyncEngineSession::DeleteContact(TRequestStatus& aReqStatus,
+ TUid aPhonebookUid,
+ TContactItemId aId)
+ {
+ LOGENGINE3(_L8("RSyncEngineSession::DeleteContact(): 0x%08x"),
+ aPhonebookUid, aId);
+
+ SendReceive(ESyncDeleteCntFromICC, TIpcArgs(aPhonebookUid.iUid, aId),
+ aReqStatus);
+ } // RSyncEngineSession::DeleteContact
+
+
+/**
+ * Cancels an existing WriteContact request.
+ *
+ * @param aPhonebookUid TUid of the ICC phonebook to cancel.
+ *
+ * @capability WriteUserData
+ */
+void RSyncEngineSession::DeleteContactCancel(TUid aPhonebookUid)
+ {
+ LOGENGINE2(_L8("RSyncEngineSession::DeleteContactCancel(): 0x%08x"),
+ aPhonebookUid);
+
+ SendReceive(ESyncDeleteCntFromICCCancel, TIpcArgs(aPhonebookUid.iUid));
+ } // RSyncEngineSession::DeleteContactCancel
+