diff -r 000000000000 -r e686773b3f54 pimprotocols/phonebooksync/Server/SyncEngineClient.cpp --- /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(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 +