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

// Contains method implementations for the Active Object classes used by the Phonebook 

// Synchroniser.

// 

//

/**

 @file

 @internalComponent

*/

#include "common.h"

#include "Phonebook.h"

#include "PhonebookManager.h"

#include "SyncContactICCEntry.h"

#include "phbksynclog.h"

#include "phbksyncsvr.h"

#include "SyncEngineSession.h"

#include "SyncEngineServer.h"

#include "phbksyncsess.h"

#include "SyncContactsWithICC.h"

/**

 *  Number of retries to read the ICC in an ICC multiple read operation.

 */

const TInt KMaxICCReadRetryCnt = 1;

/**

 *	Delay for retry (will be multiplied by an increasing factor).

 */

const TInt KReadRetryDelayBase = 100000;

/**

 *  Static factory method used to create a CSyncContactsWithICC object.

 *

 *  @param aSession           Reference to the engine session.

 *  @param aPhonebookManager  Reference to the Phonebook Manager which stores

 *                            all the phonebook parameters.

 *  @param aDb                Reference to the database.

 *  @param aPhone             Handle to the phone object.

 *  @param aPhonebookUid      Phonebook UID for the contact to be deleted from.

 *  @param aClientMessage     Handle to the engine message request.

 */

CSyncContactsWithICC* CSyncContactsWithICC::NewL(CSyncEngineSession& aSession,

												 CPhoneBookManager& aPhoneBookManager,

												 CContactDatabase& aDb,

												 RMobilePhone& aPhone,

												 TUid aPhonebookUid,

												 const RMessage2& aClientMessage)

	{

	CSyncContactsWithICC*  self = new(ELeave) CSyncContactsWithICC(aSession,

																   aPhoneBookManager,

																   aDb,

																   aPhone,

																   aPhonebookUid,

																   aClientMessage);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	} // CSyncContactsWithICC::NewL

/**

 *  Standard constructor.

 *

 *  @param aSession           Reference to the engine session.

 *  @param aPhonebookManager  Reference to the Phonebook Manager which stores

 *                            all the phonebook parameters.

 *  @param aDb                Reference to the database.

 *  @param aPhone             Handle to the phone object.

 *  @param aPhonebookUid      Phonebook UID for the contact to be deleted from.

 *  @param aClientMessage     Handle to the engine message request.

 */

CSyncContactsWithICC::CSyncContactsWithICC(CSyncEngineSession& aSession,

										   CPhoneBookManager& aPhonebookManager,

										   CContactDatabase& aDb,

										   RMobilePhone& aPhone,

										   TUid aPhonebookUid,

										   const RMessage2& aClientMessage)

  : CActive(EPriorityNormal),

	iSession(aSession),

	iPhonebookManager(aPhonebookManager),

	iDb(aDb),

	iPhone(aPhone),

	iPhonebookUid(aPhonebookUid),

	iClientMessage(aClientMessage),

	iState(ESyncContactsWithICCStateIdle),

	iPhonebookDataPtr(NULL,0),

	iNumOfEntries(1),

	iSlotNum(1)

	{

	// NOP

	} // CSyncContactsWithICC::CSyncContactsWithICC

/**

 *  Standard destructor. This will cancel any pending active requests.

 */

CSyncContactsWithICC::~CSyncContactsWithICC()

	{

	LOGACTIVE1(_L8("~CSyncContactsWithICC()"));

	Cancel();

	delete iPhonebookData;

	iUnconfirmedEntries.Close();

	iTimer.Close();

	} // CSyncContactsWithICC::~CSyncContactsWithICC

/**

 *  Second phase constructor.

 */

void CSyncContactsWithICC::ConstructL()

	{

	LOGACTIVE1(_L8("CSyncContactsWithICC::ConstructL()"));

	//

	// Create the phonebook data buffer.

	//

	iPhonebookData = HBufC8::NewL(KPBDataClientHeap);

	iPhonebookDataPtr.Set(const_cast<unsigned char*>(iPhonebookData->Ptr()), 0, KPBDataClientHeap);

	//

	// Obtain a few bits of info now to save time later...

	//

	User::LeaveIfError(iPhonebookManager.GetPhoneBookInfo(iPhonebookUid, iPhBkInfo));

	User::LeaveIfError(iPhonebookManager.GetPhoneBookStore(iPhonebookUid, iPhone, iPhonebookStore));

	//

	// Create a timer for use later if needed...

	//

	iTimer.CreateLocal();

	CActiveScheduler::Add(this);

	} // CSyncContactsWithICC::ConstructL

/**

 *  Begin synchronising the ICC phonebook into the Contacts Database. This

 *  function begins the process be ensuring the Look-Up Table is upto date

 *  with the information from the Contacts DB. Any contact entires that are

 *  stored outside the slot range of the ICC (e.g. entries from previous ICCs)

 *  are removed.

 */

void CSyncContactsWithICC::SyncContactsWithICCL()

	{

	LOGACTIVE1(_L8("CSyncContactsWithICC::SyncContactsWithICCL()"));

	//

	// Check that we are not in use!

	//

	if (iState != ESyncContactsWithICCStateIdle)

		{

		PhBkSyncPanic(EPhBkSyncPanicDoMultipleReadError);

		}

	//

	// Fetch all current database entries into the Look-Up Table. Also we

	// need to delete all entires outside the size of the phonebook. Start by

	// getting the size of the phonebook and clearing the current table data.

	//

	TInt  phonebookSize;

	User::LeaveIfError(iPhonebookManager.GetLookUpTableSize(iPhonebookUid,

															phonebookSize));

	User::LeaveIfError(iPhonebookManager.ClearLookUpTable(iPhonebookUid));

	//

	// Get the Group ID to search for entries. If no ID exists then the

	// database does not contain any entries.

	//

	TContactItemId  groupId;

	User::LeaveIfError(iPhonebookManager.GetGroupId(iPhonebookUid, groupId));

 	//

 	// Populate the lookup table with entries from the contacts database...

 	//

 	if (groupId != KNullContactId  &&  groupId != KGoldenTemplateId)

		{

 		CContactItem*  group = iDb.ReadContactLC(groupId);

 		const CContactIdArray*  members = static_cast<CContactGroup*>(group)->ItemsContained();

 		const TInt  count = members->Count();

		TContactTextDefItem  iccSlotFieldType(KUidContactFieldICCSlot);

		CContactTextDef*  iccSlotFieldTextDef = CContactTextDef::NewLC();

		iccSlotFieldTextDef->AppendL(iccSlotFieldType);

		for (TInt item = 0;  item < count;  item++)

			{

			//

			// Read the item from the database and add to the Look-Up Table.

			// The state is unconfirmed until the synchronisation is complete.

			//

			TBuf<KTemplateNumberLength>  iccSlotField;

			iDb.ReadContactTextDefL((*members)[item], iccSlotField,

									iccSlotFieldTextDef);

			TLex  input(iccSlotField);

			TInt  slotNum = 0;

			input.Val(slotNum);

			//

			// Delete entries that are in slots exceeding the ICC slot range,

			// otherwise add them to the Look Up Table.

			//

			if (slotNum > phonebookSize)

				{

				iDb.DeleteContactL((*members)[item]);

				}

			else

				{

				User::LeaveIfError(iPhonebookManager.UpdateEntryInTable(iPhonebookUid,

																		slotNum,

																		(*members)[item],

																		ESlotUnconfirmed));

				}

			}

		CleanupStack::PopAndDestroy(2, group);

 		}

	//

	// Now begin the process of reading entries and writting them to the database.

	//

	ReadICCEntries();

	} // CSyncContactsWithICC::SyncContactsWithICCL

/** 

 *  Issues a read of one or more ICC entries.

 */

void CSyncContactsWithICC::ReadICCEntries()

	{

	LOGACTIVE1(_L8("CSyncContactsWithICC::ReadICCEntries()"));

	//

	// Now issue the ICC read and set the object Active...

	//

	iPhonebookStore.Read(iStatus, iSlotNum, 1, iPhonebookDataPtr);

	iState = ESyncContactsWithICCStateWaitForRead;

	iDbAccessRetryCount=0;

	iICCReadRetryCount=0;

	SetActive();

	LOGACTIVETIMESTAMP();

	} // CSyncContactsWithICC::ReadICCEntries

/** 

 *  Standard Active Object RunL() method to process the various sync requests.

 */

void CSyncContactsWithICC::RunL()

	{

	LOGACTIVE2(_L8("CSyncContactsWithICC::RunL() iStatus=%d)"),

			   iStatus.Int());

	switch (iState)

		{

		case ESyncContactsWithICCStateWaitForRead:

			{

			//

			// If the request was completed, cancelled or no more entries were found...

			//

			if (iStatus.Int() == KErrNone  ||

				iStatus.Int() == KErrCancel  || 

			    iStatus.Int() == KErrNotFound)

				{

				TInt  ret(iStatus.Int());

				iICCReadRetryCount=0;

				//

				// Now decode received phonebook data and store it in Contacts DB...

				//

				TRAPD(decodeErr, DecodeICCAndStoreToDbL(iSlotNum, iReceivedEntries));

				if (decodeErr != KErrNone)

					{

					iSession.Server().RollbackIccTransaction();

					if (iDbAccessRetryCount < KMaxDbAccessRetryCount  &&

						(decodeErr == KErrInUse  ||  decodeErr == KErrLocked))

						{					

						iDbAccessRetryCount++;			

						LOGACTIVE2(_L8("iDbAccessErrorCount is %d"),iDbAccessRetryCount);

						iTimer.After(iStatus, KReadRetryDelayBase*iDbAccessRetryCount);//increase the delay each time

						SetActive();

						LOGACTIVETIMESTAMP();

						}

					else

						{

						iSession.Server().CompleteDoSync(decodeErr);

						}

					return;

					}

				iDbAccessRetryCount = 0; // reset the DB retry counter

				//

				// Have we finished reading yet?

				//

				if ((iPhBkInfo.iUsedEntries < 0  ||  iReceivedEntries < iPhBkInfo.iUsedEntries)  &&

				    iSlotNum < iPhBkInfo.iTotalEntries)

					{

					//

					// Increment the slot number and read some more...

					//

					iSlotNum++;

					ReadICCEntries();

					}

				else

					{

					//

					// All entries have been read. It is okay to not find an

					// entry in the case where the TSY could not tell you how

					// many entries were used. If there was an error return now.

					//

					if (ret != KErrNone  &&  ret != KErrNotFound)

						{

						iState = ESyncContactsWithICCStateIdle;

						iSession.Server().CompleteDoSync(ret);

						return;

						}

					//

					// Request the list of unconfirmed entries to remove...

					//

					TInt  result;

					result = iPhonebookManager.GetMatchingEntries(iPhonebookUid,

																  ESlotUnconfirmed,

																  iUnconfirmedEntries);

					if (result != KErrNone)

						{

						iSession.Server().CompleteDoSync(result);

						return;

						}

					//

					// Yield and continue processing in the next RunL call.

					//

					iState = ESyncContactsWithICCStateRemoveUnconfirmedEntries;

					YieldToOtherActiveObjects();

					}

				}

			else

				{

				if (iICCReadRetryCount < KMaxICCReadRetryCnt)

					{					

					iICCReadRetryCount++;

					iPhonebookDataPtr.Zero();	

					iPhonebookStore.Read(iStatus, iSlotNum, 1, iPhonebookDataPtr);

					SetActive();

					LOGACTIVETIMESTAMP();

					}

				else

					{

					iSession.Server().CompleteDoSync(iStatus.Int());

					return;

					}

				}

			}

			break;

		case ESyncContactsWithICCStateRemoveUnconfirmedEntries:

			{

			//

			// If we have unconfirmed entries to remove, then delete one of

			// them before yielding to the scheduler (so we don't spend too

			// much time in the RunL() in one go). Otherwise we have finished.

			//

			if (iUnconfirmedEntries.Count() > 0)

				{

				//

				// Get the contact ID for the entry we are going to delete...

				//

				TContactItemId  contactId;

				TInt  result;

				result = iPhonebookManager.GetContactIdFromSlotNum(iPhonebookUid,

																   iUnconfirmedEntries[0],

																   contactId);

				if (result != KErrNone)

					{

					iSession.Server().CompleteDoSync(result);

					return;

					}

				//

				// Delete the entry...

				//				

				TRAP(result, iDb.DeleteContactL(contactId));

				if (result != KErrNone)

					{

					iSession.Server().CompleteDoSync(result);

					return;

					}

				//

				// Reset the Look-Up Table entry...

				//

				result = iPhonebookManager.UpdateEntryInTable(iPhonebookUid,

															  iUnconfirmedEntries[0],

															  KNullContactId,

															  ESlotEmpty);

				if (result != KErrNone)

					{

					iSession.Server().CompleteDoSync(result);

					return;

					}

				//

				// Remove this entry from the list and yield...

				//

				iUnconfirmedEntries.Remove(0);

				YieldToOtherActiveObjects();

				}

			else

				{

				//

				// Compress the database if needed and we are finished!

				//

				if (iDb.CompressRequired())

					{

					TRAP_IGNORE(iDb.CompactL());

					}

				iState = ESyncContactsWithICCStateIdle;

				iSession.Server().CompleteDoSync(KErrNone);

				}

			}

			break;

		case ESyncContactsWithICCStateWaitForCancel:

			{

			iState = ESyncContactsWithICCStateIdle;

			iSession.Server().CompleteDoSync(iStatus.Int());

			}

			break;

		default:

			{

			PhBkSyncPanic(EPhBkSyncPanicDoMultipleReadError);

			}

			break;

		}

	} // CSyncContactsWithICC::RunL

/**

 *  Simple function that causes the Active Object to yield to the scheduler

 *  and let any other Active Objects (such as the engine) run if they want.

 */

void CSyncContactsWithICC::YieldToOtherActiveObjects()

	{

	LOGACTIVE1(_L8("CSyncContactsWithICC::YieldToOtherActiveObjects()"));

	//

	// Post a dummy request...

	//

	iStatus = KRequestPending;

	SetActive();

	LOGACTIVETIMESTAMP();

	//

	// Now complete the dummy request...

	//

	TRequestStatus*  reqStatusPtr = &iStatus;

	User::RequestComplete(reqStatusPtr, KErrNone);

	} // CSyncContactsWithICC::YieldToOtherActiveObjects

/**

 *  Decode the phonebook entries supplied in iPhoneData. The entries are

 *  converted from TLV (Tag-Length-Value) format into the phonebook server internal

 *  (CSyncContactICCEntry) format and then written to the Contacts Database.

 *  Once they are written to the DB, the server's look-up table is updated

 *  accordingly.

 *

 *  @param aIndex            Returns the slot number of the last decoded

 *                           phonebook entry.

 *  @param aReceivedEntries  Returns the number of the received entries.

 */

void CSyncContactsWithICC::DecodeICCAndStoreToDbL(TInt& aIndex,

												  TInt& aReceivedEntries)

	{

	LOGACTIVE1(_L8("CSyncContactsWithICC::DecodeICCAndStoreToDbL()"));

	TBuf16<KPBDataClientBuf>  buffer;

	TPtrC16  bufPtr(buffer);

	TUint8  tagValue(0);

	TInt  entryCount(0);

	CPhoneBookBuffer::TPhBkTagType  dataType;

	TBool  isAdditionalNumber(EFalse); // Used to indicate beginning of an Additional Number 

	CSyncContactICCEntry::TSyncAdditionalNumber  additionalNumber;

	//

	// Allocate an ICC Entry...

	//

	CSyncContactICCEntry*  iccEntry = CSyncContactICCEntry::NewL();

	CleanupStack::PushL(iccEntry);