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