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

// Phonebook Synchroniser API Client side implementation. This file implements

// the methods used to package the client data and pass it to the front-end server

// for processing.

// 

//

/**

 @file

 @publishedAll

 @released

*/

#include "phbksync.h"

#include "common.h"

#include "Phonebook.h"

#include "PhonebookManager.h"

#include "SyncContactICCEntry.h"

#include "phbksyncsvr.h"

#include "phbksynclog.h"

/**

 *  Phonebook Synchroniser API version.

 */

const TInt  KPhonebookSyncMajorVersion = 1;

const TInt  KPhonebookSyncMinorVersion = 2;

const TInt  KPhonebookSyncBuildVersion = 1;

/**

 *  Holds any client data that is used in RPhoneBookSession requests. Typically

 *  this is data for asynchronous requests which need to be repackaged. This is

 *  currently just the RPhoneBookSession::WriteContact() APIs.

 *

 *  Its data used in an asyncronous request, that does not fit into a IPC

 *  request. E.g. It is bigger that the 4 32-bit numbers, and is not a

 *  descriptor. It must be put in a descriptor before it can be sent, and

 *  that memory has to be allocated somewhere on the client side. 

 *

 *  The API code also uses this class to ensure BC by keeping the size of R-classes

 *  constant. Future data can be added to this class as required.

 */

class CSyncClientData : public CBase

	{

public:

	static CSyncClientData* NewL();

	void ConstructL();

	CSyncClientData();

	~CSyncClientData();

public:

    //

    // The following fields allow a contact mapped in internal format and other

    // data related to the WriteContact() API call to be streamed across the IPC

    // boundary.

    //

	RPhoneBookSession::TTemplateAndBufferSize  iWrtCntTmpltIdAndBufSize;

	CSyncContactICCEntry*  iWrtCntEntry;

	CBufBase*  iWrtCntEntryBuf;

	TUid  iWrtCntDefaultPhbkUid;

	TPtrC8  iWrtCntTmpltIdAndBufSizePtr;

	TPtr8  iWrtCntSlotNumPtr;

	TPtr8  iWrtCntPhBkIDPtr;

	TPtr8  iWrtCntEntryBufPtr;

	};

/**

 *  Start the server process which lives in its own executable and rendezvous with it.

 *

 *  @return  KErrNone if successful, or an error code if not.

 */

static TInt StartPhBkSyncServer()

	{

	LOGCLIENT1(_L8("StartPhBkSyncServer()"));

	//

	// Create a new server process. Simultaneous launching of two such

	// processes should be detected when the second one attempts to

	// create the server object, failing with KErrAlreadyExists.

	//		

	_LIT(KPhBkSyncSvrExeImg, "PHBKSYNCSVREXE.EXE");

	RProcess server;

	TInt  ret = server.Create(KPhBkSyncSvrExeImg, KNullDesC);

	if (ret != KErrNone)

		{

		return ret;

		}

	//

	// Rendezvous with the server or abort startup...

	//

	TRequestStatus  status;

	server.Rendezvous(status);

	if (status != KRequestPending)

		{

		server.Kill(0);

		}

	else

		{

		server.Resume();

		}

	User::WaitForRequest(status);

	//

	// We can't use the 'exit reason' if the server paniked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone.

	//

	if (server.ExitType() == EExitPanic)

		{

		ret = KErrGeneral;

		}

	else

		{

		ret = status.Int();

		}

	server.Close();

	return ret;

	} // StartPhBkSyncServer

/**

 *  Standard constructor.

 */

EXPORT_C RPhoneBookSession::RPhoneBookSession()

  : iData(NULL)

	{

	// NOP

	} // RPhoneBookSession::RPhoneBookSession

/**

 *  Connects the client to the Phonebook Synchroniser 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 Synchroniser Server within its own executable process.

 *

 *  @return  KErrNone if successful, a system-wide error code if not. 

 *

 *  @capability None

 */

EXPORT_C TInt RPhoneBookSession::Connect()

	{

	LOGCLIENT1(_L8("RPhoneBookSession::Connect()"));

	__ASSERT_ALWAYS(iData == NULL,

					PhBkSyncPanic(EPhBkSyncPanicHandleNotClosed));

	//

	// Create a session with the server, but if it doesn't exist then start it and

	// then create a session.

	//

	TInt  result = CreateSession(PHBKSYNC_SERVER_NAME,

								 TVersion(KPhonebookSyncMajorVersion,

	                					  KPhonebookSyncMinorVersion,

	                					  KPhonebookSyncBuildVersion));

	if (result == KErrNotFound  ||  result == KErrServerTerminated)

		{

		result = StartPhBkSyncServer();

		if(result == KErrNone)

			{

			result = CreateSession(PHBKSYNC_SERVER_NAME,

								   TVersion(KPhonebookSyncMajorVersion,

	                					    KPhonebookSyncMinorVersion,

	                					    KPhonebookSyncBuildVersion));

			}

		}	

	if (result == KErrNone)

		{

		TRAP(result, iData = CSyncClientData::NewL());

		}

	//

	// If the creation of the session fails clean up session data...

	//

	if (result != KErrNone)

		{

		Close();

		}

	return result;

	} // RPhoneBookSession::Connect

/**

 *  Closes the client's session with the Phonebook Synchroniser Server. 

 *

 *  @capability None

 */

EXPORT_C void RPhoneBookSession::Close()

	{

	LOGCLIENT1(_L8("RPhoneBookSession::Close()"));

	RSessionBase::Close();

	delete iData;

	iData = NULL;

	} // RPhoneBookSession::Close

/**

 *  Returns the current version of the Phonebook Synchroniser Server.

 *

 *  @return The version of the Phonebook Synchroniser Server. 

 *

 *  @capability None

 */

EXPORT_C TVersion RPhoneBookSession::Version() const

	{

	LOGCLIENT1(_L8("RPhoneBookSession::Version()"));

	return(TVersion(KPhonebookSyncMajorVersion,

	                KPhonebookSyncMinorVersion,

	                KPhonebookSyncBuildVersion));

	} // RPhoneBookSession::Version

/**

 *  Requests the shutdown of the server when the last client disconnects.

 *  There is no support for immediate shutdown functionality. This API call

 *  can only be executed if the server is compiled as a debug release.

 *  

 *  @param aConditional  If true, subsequent connection requests from any client

 *                       will be honoured delaying shutdown until they disconnect.

 *                       If untrue, all subsequent connect requests will be denied.

 *

 *  @return  KErrNone if successful, a system-wide error code if not. 

 *

 *  @capability ReadUserData

 *  @capability WriteUserData 

 */

EXPORT_C TInt RPhoneBookSession::ShutdownServer(TBool aConditional)

	{	

	LOGCLIENT1(_L8("RPhoneBookSession::ShutdownServer()"));

	return SendReceive(ESyncShutdownServer, TIpcArgs(aConditional));

	} // RPhoneBookSession::ShutdownServer

/**

 *  Executes a manual synchronisation of the Global/GSM ADN phonebook entries.

 *

 *  @param aReqStatus  On completion, KErrNone if successful, a system-wide error 

 *                     code if not. 

 *

 *  @capability ReadUserData

 *  @capability WriteUserData

 */

EXPORT_C void RPhoneBookSession::DoSynchronisation(TRequestStatus& aReqStatus)

	{

	DoSynchronisation(aReqStatus, KUidIccGlobalAdnPhonebook);

	} // RPhoneBookSession::DoSynchronisation

/**

 *  Instructs the Phonebook Synchroniser Server to start a manual synchronisation

 *  of the ICC phonebook specified by the aPhonebook 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

 */

EXPORT_C void RPhoneBookSession::DoSynchronisation(TRequestStatus& aReqStatus,

												   TUid aPhonebookUid)

	{

	LOGCLIENT1(_L8("RPhoneBookSession::DoSynchronisation"));

	SendReceive(ESyncDoSynchronisation, TIpcArgs(aPhonebookUid.iUid), aReqStatus);

	} // RPhoneBookSession::DoSynchronisation

/**

 *  Instructs the Phonebook Synchroniser Server to verify the access to the ICC

 *  contact item stored in the Contacts database. The server is responsible for

 *  mapping the UID to the phonebook this item belongs to.

 *

 *  @param aOperation  Holds the type of check, search, edit, read.

 *  @param aId         The contact model UID of the record stored in the database.

 *

 *  @return KErrNone if operation was successful, otherwise return error

 *

 *  @capability ReadUserData

 */

EXPORT_C TInt RPhoneBookSession::ValidateContact(MContactSynchroniser::TValidateOperation aOperation, 

												 TContactItemId aId)

	{

	LOGCLIENT1(_L8("RPhoneBookSession::ValidateContact"));

	return SendReceive(ESyncValidateContact, TIpcArgs(aId, aOperation));

	} // RPhoneBookSession::ValidateContact

/**

 *  Writes the contact item to the Global/GSM ADN phonebook. This can be used

 *  to edit an existing contact or to create a new contact.

 *

 *  @param aReqStatus    On completion, KErrNone if successful, a system-wide error 

 *                       code if not.

 *  @param aContactItem  The contact item to write to the ICC card.

 *  @param aSlotNumber   The slot number to write to contact into. If set to

 *                       KSyncIndexNotSupplied the Phonebook Synchroniser Server

 *                       will use the first empty slot and aSlotNumber will contain

 *                       the slot number used on completion.

 *

 *  @capability WriteUserData

 */

EXPORT_C void RPhoneBookSession::WriteContact(TRequestStatus& aReqStatus,

                                              CContactICCEntry& aContactItem, 

											  TInt& aSlotNumber)

	{

	__ASSERT_ALWAYS(iData != NULL,

					PhBkSyncPanic(EPhBkSyncPanicNullHandle));

	//

	// The dummy phonebook ID value is used as we are the old API and must communicate

	// the ADN ID to the server. However the server may write it back and thus it must

	// be a valid memory address after this function finishes (which is before the async

	// request will complete).

	//

	iData->iWrtCntDefaultPhbkUid = KUidIccGlobalAdnPhonebook;

	WriteContact(aReqStatus, aContactItem, aSlotNumber,

	             iData->iWrtCntDefaultPhbkUid);

	} // RPhoneBookSession::WriteContact

/**

 *  Write the contact item supplied in the aContactItem parameter to the ICC

 *  phonebook specified by aPhonebookUid.

 *

 *  This method is used to edit an existing or write new entry to the ICC phonebook.

 *  When editing an existing entry the slot number will be supplied in aContactItem,

 *  whereas for new entries the new slot number will be returned in the aSlotNumber

 *  parameter. Similarly for new entries the phonebook UID will be returned in the

 *  aPhonebookUid parameter.

 *

 *  @param aReqStatus     On completion, KErrNone if successful, a system-wide error 

 *                        code if not.

 *  @param aContactItem   Contacts ICC entry.

 *  @param aPhonebookUid  UID of the ICC phonebook.

 *  @param aSlotNumber    Allocated slot number.

 *

 *  @capability WriteUserData

 */

EXPORT_C void RPhoneBookSession::WriteContact(TRequestStatus& aReqStatus, CContactICCEntry& aContactItem, 

											  TInt& aSlotNumber, TUid& aPhonebookUid)

	{

	LOGCLIENT1(_L8("RPhoneBookSession::WriteContact()"));

	//

	// Check that the sync client data is available and free any previous

	// buffer.

	//

	__ASSERT_ALWAYS(iData != NULL,

					PhBkSyncPanic(EPhBkSyncPanicNullHandle));

	//

	// Convert the entry to internal format used by PhBkSync. This is needed

	// as use of a Contact Database entry can be dependant on a transaction

	// being open, therefore an independent structure is used. Also a

	// CContactICCEntry is not streamable whereas the internal format is.

	//

	TRAPD(err, iData->iWrtCntEntry->InitialiseFromContactICCEntryL(aContactItem));

	if (err != KErrNone)

		{

		TRequestStatus*  status = &aReqStatus; 

		User::RequestComplete(status, err);

		return;

		}

	if (aSlotNumber != KSyncIndexNotSupplied)

		{

		iData->iWrtCntEntry->iSlotNum = aSlotNumber;

		}

#ifdef _DEBUG

	iData->iWrtCntEntry->LogSyncContactICCEntry();

#endif

	//

	// Stream the entry into a single buffer. This will allow the entry to be

	// read accoss the IPC boundary.

	//

	// Note: The iWrtCntEntryBuf buffer is allocated by StoreL().

	//

	if (iData->iWrtCntEntryBuf)

		{

		delete iData->iWrtCntEntryBuf;  

		iData->iWrtCntEntryBuf = NULL;

		}

	TRAP(err, iData->iWrtCntEntryBuf = iData->iWrtCntEntry->StoreL());

	if (err != KErrNone)

		{

		TRequestStatus*  status = &aReqStatus; 

		User::RequestComplete(status, err);

		return;

		}

	//

	// Setup the pointers for the transfer of the contact across the IPC

	// boundary.

	//

	iData->iWrtCntTmpltIdAndBufSize.bufferSize = iData->iWrtCntEntryBuf->Size();

	iData->iWrtCntTmpltIdAndBufSize.templateId = iData->iWrtCntEntry->iTemplateId;

	iData->iWrtCntTmpltIdAndBufSizePtr.Set(reinterpret_cast<const TText8*>(&iData->iWrtCntTmpltIdAndBufSize),

										   sizeof(RPhoneBookSession::TTemplateAndBufferSize));

	iData->iWrtCntSlotNumPtr.Set(reinterpret_cast<TText8*>(&aSlotNumber),

								 sizeof(aSlotNumber), sizeof(aSlotNumber));

	iData->iWrtCntPhBkIDPtr.Set(reinterpret_cast<TText8*>(&aPhonebookUid),

								sizeof(aPhonebookUid), sizeof(aPhonebookUid));

	iData->iWrtCntEntryBufPtr.Set(iData->iWrtCntEntryBuf->Ptr(0));

	TIpcArgs  args(&iData->iWrtCntTmpltIdAndBufSizePtr,

	               &iData->iWrtCntSlotNumPtr,

	               &iData->iWrtCntPhBkIDPtr,

	               &iData->iWrtCntEntryBufPtr);

	SendReceive(ESyncWriteCntToICC, args, aReqStatus);

	//

	// This function uses the session client data space to store encoded

	// parameters before they are sent to the front-end server.  This means

	// that there is a small risk that if another call to WriteContact is made

	// before this one completes, then the data maybe corrupted.

	//

	// To prevent this we issue a synchronous request here. This will ensure

	// that at a minimum the request is read by the server and pre-processed

	// such that the data and pointer locations are read and stored inside the

	// server.

	//

	// This leaves only a risk that if the requests are ADN single phonebook

	// API versions, then the dummy Phonebook ID may be overwritten. This is

	// of course not a problem as the dummy value is not used.

	//

	SendReceive(ESyncFlushInterfaceQueue, TIpcArgs());

	} // RPhoneBookSession::WriteContact

/**

 *  Deletes the contact item from the ICC card.

 *

 *  @param aReqStatus  On completion, KErrNone if successful, a system-wide error 

 *                     code if not.

 *  @param aId         The contact item to delete. 

 *

 *  @capability WriteUserData

 */

EXPORT_C void RPhoneBookSession::DeleteContact(TRequestStatus& aReqStatus, TContactItemId aId)

	{

	LOGCLIENT1(_L8("RPhoneBookSession::DeleteContact()"));

	SendReceive(ESyncDeleteCntFromICC, TIpcArgs(aId), aReqStatus);

	} // RPhoneBookSession::DeleteContact

/**

 *  Returns information about the supported fields within an ICC phonebook entry. 

 *

 *  The TContactFieldFormat type defines the information available for each field 

 *  and TContactFieldsV1 is a collection of this information for all supported 

 *  field types. The client can use the field information to tailor its UI so 

 *  that user can only enter fields with the maximum number of supported characters.

 *

 *  The only fields supported by GSM ADN phonebook are the name, number and ICC 

 *  slot number, so these are the only fields included in TContactFieldsV1.

 *

 *  TContactFieldsV2 is used to contain the new USIM phonebook fields.

 *

 *  TContactFieldsV3 is an extension of TContactFieldsV2 and contains additional

 *  information on the fields supported by the USIM phonebooks.

 *

 *  @param aContactFields  On return, the packaged TContactFieldsV1/V2/V3

 *                         is filled with the supported field information.

 *

 *  @return KErrNone if successful, a system-wide error code if not. 

 *

 *  @capability None

 */

EXPORT_C TInt RPhoneBookSession::GetContactFormat(TDes8& aContactFields)

	{

	LOGCLIENT1(_L8("RPhoneBookSession::GetContactFormat()"));

	TUid  phonebook(KUidIccPhonebookNotSpecified);

	TContactFieldsV1Pckg*  contactFieldsV1Pckg = static_cast<TContactFieldsV1Pckg*>(&aContactFields);

	TContactFieldsV1&  contactFieldsV1 = (*contactFieldsV1Pckg)();

	TContactFieldsV1::TContactFieldsExtensionId  extensionId = static_cast<TContactFieldsV1::TContactFieldsExtensionId>(contactFieldsV1.ExtensionId());

	if (extensionId == TContactFieldsV1::KPhBkSyncTContactFieldsV2)

		{

		TContactFieldsV2Pckg*  contactFieldsV2Pckg = static_cast<TContactFieldsV2Pckg*>(&aContactFields);

		TContactFieldsV2&  contactFieldsV2 = (*contactFieldsV2Pckg)();

		phonebook = contactFieldsV2.iPhonebook;

		}

	else if (extensionId == TContactFieldsV1::KPhBkSyncTContactFieldsV3)

		{

		TContactFieldsV3Pckg*  contactFieldsV3Pckg = static_cast<TContactFieldsV3Pckg*>(&aContactFields);

		TContactFieldsV3&  contactFieldsV3 = (*contactFieldsV3Pckg)();

		phonebook = contactFieldsV3.iPhonebook;

		}

	else

		{