// Copyright (c) 2001-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:

//

#include "TE_PhBkSyncBase.h"

// all test step header files

#include "TestOpenSteps.h"

#include "TestConnectSteps.h"

#include "TestDeleteContactSteps.h"

#include "TestDoSynchronisationSteps.h"

#include "TestGetContactFormatSteps.h"

#include "TestGetSyncModeSteps.h"

#include "TestOtherSteps.h"

#include "TestSetSyncModeSteps.h"

#include "TestValidateContactSteps.h"

#include "TestVersionSteps.h"

#include "TestWriteContactSteps.h"

#include "TestReadingIniFile.h"

CTestStepPhbkSync::CTestStepPhbkSync()

	{

	iUidIccGlobalAdnPhonebookCallByRef = KUidIccGlobalAdnPhonebook;

	iUidIccGlobalSdnPhonebookCallByRef = KUidIccGlobalSdnPhonebook;

	iUidIccGlobalLndPhonebookCallByRef = KUidIccGlobalLndPhonebook;

	iUidUsimAppAdnPhonebookCallByRef = KUidUsimAppAdnPhonebook;

	iUidIccGlobalFdnPhonebookCallByRef = KUidIccGlobalFdnPhonebook;

	iPhoneBook[0] = KUidIccGlobalAdnPhonebook;

	iPhoneBook[1] = KUidIccGlobalSdnPhonebook;

	iPhoneBook[2] = KUidIccGlobalLndPhonebook;

	iPhoneBook[3] = KUidUsimAppAdnPhonebook;

	iPhoneBook[4] = KUidIccGlobalFdnPhonebook;

	}

/**

 *  Deletes the PhBkSync INI file.

 */

void CTestStepPhbkSync::DestroyDefaultIniFileL()

	{

	// Delete contacts database and phonebook sync ini file 

	RFs fs;

	User::LeaveIfError(fs.Connect()); // Connect to File server

	CleanupClosePushL(fs);

	TInt err(fs.Delete(KPhbkSyncIniFile)); // Delete PhBkSync.INI file

	if(!(err == KErrNone  ||  err == KErrNotFound  ||  err == KErrPathNotFound)) // Deleted successfully OR no default INI file

		User::Leave(err);

	CleanupStack::PopAndDestroy(); // fs

	}

/**

 *  Deletes the Contacts Database and the PhBkSync INI file.

 */

void CTestStepPhbkSync::DestroyDefaultFilesL()

	{

	// Delete contacts database and phonebook sync ini file 

	RFs fs;

	User::LeaveIfError(fs.Connect()); // Connect to File server

	TInt err(fs.Delete(KPhbkSyncIniFile)); // Delete PhBkSync.INI fileNI file

	if(!(err == KErrNone  ||  err == KErrNotFound ||  err == KErrPathNotFound  )) // Deleted successfully OR no default INI file

		User::Leave(err);

	TRAP(err,CContactDatabase::DeleteDefaultFileL()); // Delete default ContactsDb 

	if(!(err == KErrNone  ||  err == KErrNotFound)) // Deleted successfully OR no default INI file

		User::Leave(err);

	}

TVerdict CTestStepPhbkSync::doTestStepPreambleL()

	{

	__UHEAP_MARK;

	iScheduler = new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(iScheduler);

	iSecureBackupEngine = CSBEClient::NewL();

	TInt ret = iSession.Connect();

	TESTCHECKL(ret, KErrNone);

	return TestStepResult();

	}

TVerdict CTestStepPhbkSync::doTestStepPostambleL()

	{

	iSession.Close();

	delete iSecureBackupEngine;

	iSecureBackupEngine = NULL;

	delete iScheduler;

	iScheduler = NULL;

	__UHEAP_MARKEND;

	return TestStepResult();

	}

/** 

 * Change the synchronisation mode for the given phone book.

 */

void CTestStepPhbkSync::ChangeSyncModeL(RPhoneBookSession::TPhonebookSyncMode aMode, TUid aPhonebookUid)

	{

	User::LeaveIfError(iSession.SetSyncMode(aMode, aPhonebookUid));

	}

/** 

 * Check the synchronisation mode is the same as aMode for given phone book.

 */

void CTestStepPhbkSync::CheckSyncModeL(RPhoneBookSession::TPhonebookSyncMode aMode, TUid aPhonebookUid)

	{

	RPhoneBookSession::TPhonebookSyncMode mode;

	User::LeaveIfError(iSession.GetSyncMode(mode, aPhonebookUid));

	TESTCHECK(mode, aMode);

	}

void CTestStepPhbkSync::CheckCacheStateValidL(TUid aPhonebookUid)

	{

	RPhoneBookSession::TSyncState state;

	TInt  ret;

	ret = iSession.GetPhoneBookCacheState(state, aPhonebookUid);

	while (ret != KErrNone  ||  state == RPhoneBookSession::EUnsynchronised) 

		{

		User::After(KOneSeconduS);  // Wait until cache becomes usable 

		ret = iSession.GetPhoneBookCacheState(state, aPhonebookUid);

		}

	// Cache now in valid state 

	TESTCHECKL(state, RPhoneBookSession::ECacheValid);

	}

void CTestStepPhbkSync::CheckCacheStateInvalidL(TUid aPhonebookUid)

	{

	User::After(3000000); // Delay is needed to prove that synchronisation has not been carried out 

	RPhoneBookSession::TSyncState state;

	TInt  ret;

	ret = iSession.GetPhoneBookCacheState(state, aPhonebookUid);

	if (ret == KErrNone)

		{

		TESTCHECKL(state, RPhoneBookSession::EUnsynchronised);

		}

	}

void CTestStepPhbkSync::CheckCacheStateErrorL(TUid aPhonebookUid)

	{

	User::After(3000000); // Delay is needed to prove that synchronisation has not been carried out 

	RPhoneBookSession::TSyncState state;

	TInt  ret;

	ret = iSession.GetPhoneBookCacheState(state, aPhonebookUid);

	if (ret == KErrNone)

		{

		TESTCHECKL(state, RPhoneBookSession::EErrorDuringSync);

		}

	}

void CTestStepPhbkSync::WaitForIccToBecomeLockedL()

	{

	TContactItemId validContactId;

	validContactId = GetValidUIDFromContactsDbL(KUidIccGlobalAdnPhonebook);

	TESTCHECKCONDITIONL(validContactId != KNullContactId);

	// Wait for ICC to become locked 

	TInt result = KErrNone;

	result = iSession.ValidateContact(MContactSynchroniser::ERead, validContactId);

	while (result != KErrAccessDenied) 

		{

		result = iSession.ValidateContact(MContactSynchroniser::ERead, validContactId);

		User::After(1000000);

		}

	TESTCHECKL(result, KErrAccessDenied);

	}

/** 

 * Convert the given phonebookUid into its corresponding EnumId used 

 * used by phonebook internally.

 */

MyCSyncContactICCEntry::TSyncPhoneBook CTestStepPhbkSync::convertPhonebookUid2Enum(TUid aPhonebookUid)

	{

	if (aPhonebookUid == KUidIccGlobalAdnPhonebook)

		return MyCSyncContactICCEntry::EIccGlobalAdnPhonebook;

	else if (aPhonebookUid == KUidIccGlobalSdnPhonebook)

		return MyCSyncContactICCEntry::EIccGlobalSdnPhonebook;

	else if (aPhonebookUid == KUidIccGlobalLndPhonebook)

	    return MyCSyncContactICCEntry::EIccGlobalLndPhonebook;

	else if (aPhonebookUid == KUidUsimAppAdnPhonebook)

		return MyCSyncContactICCEntry::EUsimAppAdnPhonebook;

	else if (aPhonebookUid == KUidIccGlobalFdnPhonebook)

		return MyCSyncContactICCEntry::EIccGlobalFdnPhonebook;

	else

		return MyCSyncContactICCEntry::EIccGlobalAdnPhonebook;

	}

void CTestStepPhbkSync::DoWriteContactToICCL(MyCSyncContactICCEntry* aIccEntryInternal,

					     TUid&		      aPhonebook,

					     TRequestStatus&	      aStatus,

					     RPhoneBookSession* aSession) 

{

	// to get the template associated with the given phonebook

	// Use the contacts model API to get the template ID rather than

	// the RPhonebookSession as this is how it is going to be done in reality 

	CContactDatabase *iDb = NULL;

	TRAPD(err,iDb = CContactDatabase::OpenL()); // open existing database

	CleanupStack::PushL(iDb);

	CContactItem* iccTemplate = NULL;

	TESTCHECKL(err, KErrNone);

	if (err == KErrNone)

		{

		TContactItemId templateId = iDb->ICCTemplateIdL(aPhonebook); 

		iccTemplate = iDb->ReadContactL(templateId);

		}

	CleanupStack::PopAndDestroy(); // iDb

	CleanupStack::PushL(iccTemplate); 

	// Create an ICC (exteranl format) entry

	CContactICCEntry* iccEntryExternal; 

	// If an overwrite is being attempted then ensure an entry with relevant UID is used

	if (aIccEntryInternal->iContactUID > 0)

		{

		TContactItemId realId(GetValidUIDFromContactsDbL(aPhonebook, EFalse));

		iccEntryExternal = static_cast<CContactICCEntry*> (iDb->ReadContactL(realId));

		}

	else

		{

		iccEntryExternal = CContactICCEntry::NewL(*iccTemplate); // Create an ICC entry

		}

	CleanupStack::PopAndDestroy(); // iccTemplate

	CleanupStack::PushL(iccEntryExternal);

	// Create phone number field 

	if(aIccEntryInternal->iNumber.Length() != KErrNone) 

		{

		TBuf<RMobilePhone::KMaxMobileTelNumberSize> number;

		if(aIccEntryInternal->iTON==RMobilePhone::EInternationalNumber) 

			{

			// Append '+' prefix if International Number

			number.Append(KInternationalPrefix); 

			}

		number.Append(aIccEntryInternal->iNumber);

		AddTextFieldToIccContactL(KStorageTypeText, 

					  KUidContactFieldPhoneNumber, 

					  KUidContactFieldVCardMapTEL, 

					  number, 

					  iccEntryExternal,

					  0); // 0 means the first instance

		}

	// Check whether this is hidden entry and set its hidden attributes 

	if(aIccEntryInternal->iIsHidden) 

		{

		iccEntryExternal->SetHidden(ETrue);

		}

	// Additional numbers 

	TInt count(aIccEntryInternal->iNumberList->Count());

	TInt i(0);

	for(i=0; i<count; ++i) 

		{

		MyCSyncContactICCEntry::TSyncAdditionalNumber additionalNum(aIccEntryInternal->iNumberList->At(i));

/*****

		// Add additional number alpha string

		TBuf<CSyncContactICCEntry::KMaxPhBkNameSize> numberString;

		numberString.Copy(additionalNum.iNumberString);

		AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldSecondName, KUidContactFieldVCardMapUnusedN, numberString, iccEntryExternal,i);

*****/

		// Actual number

		TBuf<RMobilePhone::KMaxMobileTelNumberSize> number;

		if(additionalNum.iTON==RMobilePhone::EInternationalNumber)

			{

			number.Append(KInternationalPrefix); // Append '+' prefix if International Number

			}

		number.Append(additionalNum.iNumber);

		AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldPhoneNumber, KUidContactFieldVCardMapTEL, number, iccEntryExternal,i+1);

		}

	// Create name field(s)

	count = aIccEntryInternal->iNameList->Count();

	for(i=0; i<count; ++i)

		{

		MyCSyncContactICCEntry::TSyncEntryName nameField;

		nameField.Copy(aIccEntryInternal->iNameList->At(i));

		// First name only is stored as Family Name

		if (i == 0)

			{

			AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldFamilyName, KUidContactFieldVCardMapUnusedN, nameField, iccEntryExternal, i);

			}

		else

			{

			AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldSecondName, KUidContactFieldVCardMapUnusedN, nameField, iccEntryExternal, i-1);

			}

		}

	// Create group field(s)

	count = aIccEntryInternal->iGroupList->Count();

	for(i=0; i<count; ++i) 

		{

		MyCSyncContactICCEntry::TSyncEntryName groupField;

		groupField.Copy(aIccEntryInternal->iGroupList->At(i));

		AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldICCGroup, KUidContactFieldVCardMapUnusedN, groupField, iccEntryExternal,i);

		}

	// Create e-mail field(s)

	count = aIccEntryInternal->iEmailList->Count();

	for(i=0; i<count; ++i) 

		{

		MyCSyncContactICCEntry::TSyncEntryName emailField;

		emailField.Copy(aIccEntryInternal->iEmailList->At(i));

		AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldEMail, KUidContactFieldVCardMapUnusedN, emailField, iccEntryExternal,i);

		}

	// Create slot number field

	if(aIccEntryInternal->iSlotNum!=KSyncIndexNotSupplied) // it is not a new entry so slot number is supplied

		{

		// Create slot number field

		HBufC* buf = HBufC::NewL(5);

		TPtr indexPtr(buf->Des());

		indexPtr.AppendNum(aIccEntryInternal->iSlotNum);

		TPtrC indexPtrC = indexPtr.Mid(0);

		AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldICCSlot, KUidContactFieldVCardMapNotRequired, indexPtrC, iccEntryExternal,0);

		delete buf;

		}

	// Create phonebook type field

	TBuf<KFieldLength> buf;

	buf.FillZ();

	buf.Zero();

	buf.AppendNum(static_cast<TInt>(aIccEntryInternal->iPhonebook)); 

	TPtrC phonebookPtrC(buf.Ptr());

	AddTextFieldToIccContactL(KStorageTypeText, KUidContactFieldICCPhonebook, KUidContactFieldVCardMapNotRequired, phonebookPtrC, iccEntryExternal,0);

	// Send a Write-Contact-ICC request

	// Here you need to pass an EXTERNAL format not INTERNAL as this is what 

	// the plug-in will pass to the server

	TInt iSlotNumCallByRef = aIccEntryInternal->iSlotNum;

	if (aSession != NULL)

		{

		aSession->WriteContact(aStatus, *iccEntryExternal, iSlotNumCallByRef, aPhonebook); 

		}

	else

		{

		iSession.WriteContact(aStatus, *iccEntryExternal, iSlotNumCallByRef, aPhonebook); 

		}

	User::WaitForRequest(aStatus);

	// if a new slot number is allocated, write it back to EXTERNAL object

	if (aIccEntryInternal->iSlotNum == KSyncIndexNotSupplied) 

		{ 

		// a new slot should be allocated and put into "iSlotNumCallByRef".

		// In case the phonebook is full, write will faile which is why a

		// TESTCHECKCODITION(iSlotNumCallByRef != KSyncIndexNotSupplied) is not done here.

		aIccEntryInternal->iSlotNum = iSlotNumCallByRef;

		}

	CleanupStack::PopAndDestroy();   // iccEntryExternal

	}

/** Do a manual synchronisation */

void CTestStepPhbkSync::DoSyncL(TUid aPhonebookUid, TInt aExpectedErr, TBool aIgnoreErr)

	{

	TRequestStatus status; 

	iSession.DoSynchronisation(status, aPhonebookUid);

	User::WaitForRequest(status);

	if (!aIgnoreErr) 

		{ 

		TESTCHECK(status.Int(), aExpectedErr);

		}

	else 

		{

		// to make sure the given error code != KErrNone

		// and simply ignore the returned error message

		TESTCHECKCONDITION(status.Int()!=KErrNone);

		}

	}

/** Do a manual synchronisation with cache state change notification*/

void CTestStepPhbkSync::DoSyncAndNotificationL(TUid aPhonebookUid, TInt aExpectedErr,

											   RPhoneBookSession::TSyncState aExpectedState,

											   TRequestStatus& aNotifyStatus, TBool aIgnoreErr)

	{

	TRequestStatus status; 

	iSession.DoSynchronisation(status, aPhonebookUid);

	User::WaitForRequest(aNotifyStatus);

	User::WaitForRequest(status);

	RPhoneBookSession::TSyncState state;

	iSession.GetPhoneBookCacheState(state, aPhonebookUid);

	if (!aIgnoreErr) 

		{ 

		TESTCHECKL(status.Int(), aExpectedErr);

		TESTCHECK(state, aExpectedState);

		}

	else 

		{

		// to make sure the given error code != KErrNone

		// and simply ignore the returned error message

		TESTCHECKCONDITIONL(status.Int() != KErrNone);

		}

	}

/**

 	Instruct the PhBkSync server to configure to a 'Full' state

 	by using the Secure Backup interface. This will cause the

 	server to reconnect to ETel and SIMTSY.

 */

void CTestStepPhbkSync::ConfigurePhbkSyncToFullL()

	{

	//

	// Ensure that the Secure Backup system does not currently think

	// it is performing a backup or restore.

	//

	iSecureBackupEngine->SetBURModeL(TDriveList(_L8("C")),

									 EBURNormal, ENoBackup);

	//

	// Connect to the server to ensure that the server is running and

	// responding.

	//

	RPhoneBookSession  phoneBookSession;

	RPhoneBookSession::TPhonebookSyncMode  dummySyncMode;

	TInt ret;

	ret = phoneBookSession.Connect();

	TESTCHECKL(ret, KErrNone);

	ret = KErrNotReady;

	while (ret != KErrNone)

		{

		ret = phoneBookSession.GetSyncMode(dummySyncMode);

		if (ret != KErrNone)

			{

			User::After(1);

			}

		}

	phoneBookSession.Close();

	} // CTestStepPhbkSync::ConfigurePhbkSyncToFullL

/**

 	Instruct the PhBkSync server to unconfigure to an 'Idle' state

 	by using the Secure Backup interface. This will cause the

 	server to disconnect from ETel and SIMTSY. This is effectively

 	the same as shutting down the server, but can be performed on

 	release versions.

 */

void CTestStepPhbkSync::ConfigurePhbkSyncToIdleL()

	{

	//

	// Connect to the server to ensure that the server is running.

	//

	RPhoneBookSession  phoneBookSession;

	TInt ret;

	ret = phoneBookSession.Connect();

	TESTCHECKL(ret, KErrNone);

	//

	// Ensure that the Secure Backup system does not currently think

	// it is performing a backup or restore.

	//

	iSecureBackupEngine->SetBURModeL(TDriveList(_L8("C")),

									 EBURBackupFull, EBackupBase);

	//

	// Check that the server is responding.

	//

	RPhoneBookSession::TPhonebookSyncMode  dummySyncMode;

	ret = KErrNone;

	while (ret == KErrNone)

		{

		ret = phoneBookSession.GetSyncMode(dummySyncMode);

		if (ret == KErrNone)

			{

			User::After(1);

			}

		}

	phoneBookSession.Close();

	} // CTestStepPhbkSync::ConfigurePhbkSyncToIdleL

/** 

 * Set the SIM TSY test number to run

 *

 */

void CTestStepPhbkSync::SetSimTsyTestNumberL(TInt aTestNumber, TBool aIgnoreErr)

	{

	RProperty testNumberProperty;

	User::LeaveIfError(testNumberProperty.Attach(KUidPSSimTsyCategory, KPSSimTsyTestNumber));

	CleanupClosePushL(testNumberProperty);

	TRequestStatus status;

	testNumberProperty.Subscribe(status);

	User::LeaveIfError(testNumberProperty.Set(KUidPSSimTsyCategory,KPSSimTsyTestNumber,aTestNumber));

	User::WaitForRequest(status);

	User::LeaveIfError(status.Int());

	TInt testNumberCheck;

	User::LeaveIfError(testNumberProperty.Get(testNumberCheck));

	if (aTestNumber != testNumberCheck)

	{

		User::Leave(KErrNotFound);