// Copyright (c) 1999-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 "smstestutils.h"

#include <e32test.h>

#include <f32fsys.h>

#include <s32file.h>

#include <e32uid.h>

#include <txtrich.h>

#include <txtfmlyr.h>

#include <msvids.h>

#include <msvuids.h>

#include <e32std.h>

#include <smuthdr.h>

#include <msvsysagentaction.h>

#include <smscmds.h>

#include <smsclnt.h>

#include <smutset.h>

#include <msgtestscripts.h>

#include <biouids.h>

#include <msvschedulesettings.h>

#include <commsdattypesv1_1.h>

#include <commsdat.h>

#include <etelmm.h>

#include <logsmspdudata.h>

using namespace CommsDat;

#include "EmsMsgTestUtils.h"

#include "emstestutils.h"

#include <csmsaccount.h>

#include <msvoffpeaktime.h>

#include "CAsyncWaiter.h"

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <e32property.h>

// Constants

//

const TInt KUidNetworkBarsCmtValue=0x100052DB;

const TInt KUidCmtPowerValue=0x100052D9;

/**

	@enum	TSANetworkBarsCmt

	Enum defining the system agent network commands

	@since	6.1

*/

enum TSANetworkBarsCmt

	{

	ENBars_0,		//<

	ENBars_1,		//<

	ENBars_2,		//<

	ENBars_3,		//<

	ENBars_4,		//<

	ECmtPowerOn,	//< Specifies that the power is on

	ECmtPowerOff	//< Specifies that the power is off

	};

/**

	@enum	TSACmtPower

	Enum defining the system agent commands for power

	@since	6.1

*/

enum TSACmtPower

	{	

	ECmtOn,		//< Specifies that the power is on

	ECmtOff		//< Specifies that the power is off

	};

EXPORT_C CSmsTestUtils::~CSmsTestUtils()

	{

	Reset();

	delete iServiceSettings;

	delete iRichText;

	delete iCharFormat;

	delete iParaFormat;

	iRTest.Printf(_L("Waiting 3 seconds for the msg server to close...\n"));

	User::After(3000000);

	}

EXPORT_C void CSmsTestUtils::AddSystemAgentConditionsL()

	{

	CMsvSysAgentActions* actions = new (ELeave) CMsvSysAgentActions();

	CleanupStack::PushL(actions);

	CMsvScheduleSettings* schSettings = CMsvScheduleSettings::NewL();

	CleanupStack::PushL(schSettings);

	CMsvOffPeakTimes* offPeakTimes = new (ELeave) CMsvOffPeakTimes();

	CleanupStack::PushL(offPeakTimes);

	CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(errorActions);

	CSmsAccount* account = CSmsAccount::NewLC();

	account->LoadSettingsL(*schSettings, *offPeakTimes, *errorActions, *actions);

	actions->iDefault.iAction = ESendActionRetryImmediately;

	actions->iDefault.iRetries = ESendRetriesFixed;

	actions->iDefault.iRetrySpacing = ESendRetrySpacingStatic;

	actions->iDefault.SetMaxRetries(1);

	TMsvSysAgentConditionAction condAction;

	condAction.iUseDefaultSysAgentAction = ETrue;

	condAction.iCondition.iVariable = KMsvTestUidPhonePwr;

	condAction.iCondition.iState = EMsvTestPhoneOn;

	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;

	actions->AppendL(condAction);

	condAction.iCondition.iVariable = KMsvTestUidSIMStatus;

	condAction.iCondition.iState = EMsvTestSimOk;

	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;

	actions->AppendL(condAction);

	condAction.iCondition.iVariable = KMsvTestUidNetworkStatus;

	condAction.iCondition.iState = EMsvTestNetworkAvailable;

	condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals;

	actions->AppendL(condAction);

//	TMsvSendErrorAction action;

//	TBool condMet = actions->ConditionsMetL(action);

	account->SaveSettingsL(*schSettings, *offPeakTimes, *errorActions, *actions);

	CleanupStack::PopAndDestroy(4, account);    	

	}

/**

	@fn				NotifySaPhoneOnL()

	Intended Usage	:	To notify the system agent that the phone is on.

	@since			6.1

	@pre 			None

	@post			System agent has been notified.

 */

EXPORT_C void CSmsTestUtils::NotifySaPhoneOnL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOn));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidCmtPowerValue, ECmtOn));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidNetworkBarsCmtValue, ECmtPowerOn));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, 0x100052E7, 8));

	}

/**

	@fn				NotifySaPhoneOffL()

	Intended Usage	:	To notify the system agent that the phone is off.

	@since			6.2

	@pre 			None

	@post			System agent has been notified.

 */

EXPORT_C void CSmsTestUtils::NotifySaPhoneOffL()

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOff));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidCmtPowerValue, ECmtOff));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidNetworkBarsCmtValue, ECmtPowerOff));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, 0x100052E7, 8));

	}

EXPORT_C void CSmsTestUtils::WaitForInitializeL()

/**

	Initialize the phone for the tsy. This will prevent message sends from completing with KErrNotReady

*/

	{

	TName tsy;

	CMDBSession* dbSession = CMDBSession::NewL(CMDBSession::LatestVersion());

	CleanupStack::PushL(dbSession);

	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

	TRAPD(err, globalSettingsRecord.LoadL(*dbSession));

	if(err != KErrNone)

		{

		User::Leave(KErrNotFound);				

		}

	CCDModemBearerRecord *modemRecord = static_cast<CCDModemBearerRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));		

	CleanupStack::PushL(modemRecord);	

	modemRecord->SetRecordId(((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iModemForPhoneServicesAndSMS); 

	modemRecord->LoadL(*dbSession);

	tsy = modemRecord->iTsyName;	

	CleanupStack::PopAndDestroy(2); //dbSession, modemRecord

	RTelServer server;

	User::LeaveIfError(server.Connect());

	CleanupClosePushL(server);

	User::LeaveIfError(server.LoadPhoneModule(tsy));

	// Find the phone corresponding to this TSY and open a number of handles on it

	TInt numPhones;

	User::LeaveIfError(server.EnumeratePhones(numPhones));

	RPhone phone;

	while (numPhones--)

		{

		TName phoneTsy;

		User::LeaveIfError(server.GetTsyName(numPhones,phoneTsy));

		if (phoneTsy.CompareF(tsy)==KErrNone)

			{

			RTelServer::TPhoneInfo info;

			User::LeaveIfError(server.GetPhoneInfo(numPhones,info));

			User::LeaveIfError(phone.Open(server,info.iName));

			CleanupClosePushL(phone);

			const TInt err = phone.Initialise();

			User::LeaveIfError(err);

			CleanupStack::PopAndDestroy(&phone);

			break;

			}

		}

	CleanupStack::PopAndDestroy(&server);

	}

EXPORT_C CSmsTestUtils* CSmsTestUtils::NewL(RTest& aRTest, TUint aCreationFlags)

	{

	CSmsTestUtils* self = NewLC(aRTest, aCreationFlags);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CSmsTestUtils* CSmsTestUtils::NewLC(RTest& aRTest, TUint aCreationFlags)

	{

	CSmsTestUtils* self = new(ELeave) CSmsTestUtils(aRTest);

	CleanupStack::PushL(self);

	self->ConstructL(aCreationFlags);

	return self;

	}

void CSmsTestUtils::Reset()

	{

	if (iSmsClientMtm)

		{

		delete iSmsClientMtm;

		iSmsClientMtm=NULL;

//		iMsvEntry=NULL;

		}

	CMsvTestUtils::Reset();

	}

//

// Register a Sms Mtm server DLL

//

EXPORT_C void CSmsTestUtils::CreateSmsServerMtmRegL()

	{

	CreateServerMtmRegL(KUidMsgTypeSMS, _L("SMS"), KSmsServerMtmFileName(), KSmsClientMtmFileName(), TMsvTestDllInfo(KSmsUiMtmFileFileName,2), TMsvTestDllInfo(KSmsUiMtmFileFileName,1), KUidMsgTypeSMS, KSmsDataComponentFileName);

	}

EXPORT_C TMsvId CSmsTestUtils::CreateSmsServiceL()

	{

	// create service in root

	TInt err = KErrNone;

	iSmsServiceId = 0;

	TRAP(err, ServiceIdL(KUidMsgTypeSMS, iSmsServiceId));

	if (err)

		{

		if (!iServiceSettings)

			{

			iServiceSettings = CSmsSettings::NewL();

			}

		CSmsAccount* account = CSmsAccount::NewLC();

		account->InitialiseDefaultSettingsL(*iServiceSettings);

		ServiceIdL(KUidMsgTypeSMS, iSmsServiceId);

		iServiceSettings->SetValidityPeriod(ESmsVPWeek);	// week

		iServiceSettings->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger); //relative

		iServiceSettings->AddServiceCenterL(_L("Vodafone"), _L("+4477850016005"));

		iServiceSettings->AddServiceCenterL(_L("Sonera"), _L("+358405202000"));

		iServiceSettings->SetDefaultServiceCenter(1);

		iServiceSettings->SetReplyQuoted(EFalse);

		iServiceSettings->SetRejectDuplicate(ETrue);

		iServiceSettings->SetDelivery(ESmsDeliveryImmediately);

		iServiceSettings->SetDeliveryReport(ETrue);

		iServiceSettings->SetReplyPath(EFalse);

		iServiceSettings->SetMessageConversion(ESmsConvPIDNone);

		iServiceSettings->SetCanConcatenate(ETrue);

		account->SaveSettingsL(*iServiceSettings);

		CMsvScheduleSettings* schSettings = CMsvScheduleSettings::NewL();

		CleanupStack::PushL(schSettings);

		CMsvOffPeakTimes* offPeakTimes = new (ELeave) CMsvOffPeakTimes();

		CleanupStack::PushL(offPeakTimes);

		CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL();

		CleanupStack::PushL(errorActions);

		CMsvSysAgentActions* sysAgentActions = new (ELeave) CMsvSysAgentActions();

		CleanupStack::PushL(sysAgentActions);

		account->LoadSettingsL(*schSettings, *offPeakTimes, *errorActions, *sysAgentActions);

		schSettings->SetLongInterval(30);

		schSettings->SetShortInterval(10);

		account->SaveSettingsL(*schSettings, *offPeakTimes, *errorActions, *sysAgentActions);

		CleanupStack::PopAndDestroy(5, account);    	

		}

	else

		{

		User::Leave(KErrAlreadyExists);

		}

	return iSmsServiceId;

	}

EXPORT_C void CSmsTestUtils::InstallSmsMtmGroupL()

	{

	InstallMtmGroupL(KSmsDataComponentFileName);

	}

EXPORT_C void CSmsTestUtils::InstantiateSmsClientMtmL()

	{

	__ASSERT_ALWAYS(iSmsServiceId, Panic(KSmsTestUtilsPanicSmsServiceIdNotSet));

	delete iSmsClientMtm;

	iSmsClientMtm = NULL;

	iSmsClientMtm = (CSmsClientMtm*) InstantiateClientMtmL(KUidMsgTypeSMS, iSmsServiceId);

	}

EXPORT_C CSmsTestUtils::CSmsTestUtils(RTest& aRTest)

: CMsvTestUtils(aRTest), iSmsServiceId(KMsvNullIndexEntryId), iSmokeTest(EFalse)

	{

	}

EXPORT_C void CSmsTestUtils::ConstructL(TUint aFlags)

	{

	CMsvTestUtils::ConstructL(aFlags);

	iParaFormat = CParaFormatLayer::NewL();

	iCharFormat = CCharFormatLayer::NewL();

	iRichText = CRichText::NewL(iParaFormat, iCharFormat);

	}

EXPORT_C void CSmsTestUtils::SaveBodyToFileL(TMsvId aId)

	{

	SetEntryL(aId);

	CMsvStore* store = ReadStoreL();

	CleanupStack::PushL(store);

	iRichText->Reset();

	store->RestoreBodyTextL(*iRichText);

	CleanupStack::PopAndDestroy(store);

	const TInt length = iRichText->DocumentLength();

	HBufC* buf = HBufC::NewLC(length);

	HBufC8* buf8 = HBufC8::NewLC(length);

	TPtr bufPtr(buf->Des());

	iRichText->Extract(bufPtr);

	buf8->Des().Copy(*buf);

	TFileName path;

	TInt bioType = Entry().iBioType;

	path.AppendNum((TUint)Entry().Id());

	path.Append(_L("-"));

	path.AppendNum(bioType);

	path.Append(_L(".body"));

	// Remove any attachments with the same name

	if (iClientServer == EClientSide)

		{

		store = iMsvEntry->EditStoreL();

		}

	else if (iClientServer == EServerSide)

		{

		store = iServerEntry->EditStoreL();

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	CleanupStack::PushL(store);

	CAsyncWaiter* waiter = CAsyncWaiter::NewL();

	CleanupStack::PushL(waiter);

	MMsvAttachmentManager& manager = store->AttachmentManagerL();

	for(TInt ii=0; ii<manager.AttachmentCount(); ++ii )

		{

		CMsvAttachment* attachment = manager.GetAttachmentInfoL(ii);

		CleanupStack::PushL(attachment);

		if( attachment->AttachmentName().CompareF(path) == 0 )

			{

			CTestActive* testActive = new (ELeave) CTestActive();

			CleanupStack::PushL(testActive);

			// found a matching attachment, remove it

			manager.RemoveAttachmentL(ii, waiter->iStatus);

			waiter->StartAndWait();

			User::LeaveIfError(waiter->Result());			

			}

		CleanupStack::PopAndDestroy(attachment);

		}

	// create a new attachment file

	CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

	CleanupStack::PushL(attachment);

	attachment->SetSize(buf->Length());

	attachment->SetAttachmentNameL(path);

	RFile file;

	manager.CreateAttachmentL(path, file, attachment, waiter->iStatus);

	CleanupStack::Pop(attachment); // ownership passed

	waiter->StartAndWait();

	User::LeaveIfError(waiter->Result());		

	CleanupClosePushL(file);

	file.Write(*buf8);

	file.Flush();

	CleanupStack::PopAndDestroy(5, buf); // file, waiter, store, buf8, buf

	}

void CSmsTestUtils::DisplayChildDetailsL(const TMsvEntry& aEntry)

	{

	iRTest.Printf(KMsvTestUtilsNewLine);

	DisplayChildL(aEntry);

	iRTest.Printf(KMsvTestUtilsNewLine);

	if ((aEntry.iMtm != KUidMsgTypeSMS && aEntry.iMtm != KUidBIOMessageTypeMtm) || aEntry.iType != KUidMsvMessageEntry)

		return;

	CMsvEntry* cEntry = iMsvSession->GetEntryL(aEntry.Id());

	CleanupStack::PushL(cEntry);

	CSmsHeader* header = DoGetHeaderLC(*cEntry);

	TBuf<256> temp;

	temp.Append(_L("\tType: SMS "));

	switch (header->Type())

		{

		case CSmsPDU::ESmsDeliver:

			temp.Append(_L("Deliver\n"));

			break;

		case CSmsPDU::ESmsSubmit:

			temp.Append(_L("Submit\n"));

			break;

		case CSmsPDU::ESmsDeliverReport:

			temp.Append(_L("Deliver Report\n"));

			break;

		case CSmsPDU::ESmsSubmitReport:

			temp.Append(_L("Submit Report\n"));

			break;

		default:

			temp.Append(_L("Other\n"));

			break;

		}

	iRTest.Printf(temp);

	temp.Zero();

	iRTest.Printf(_L("\tBio Type UID: %d\n"), aEntry.iBioType);

	iRTest.Printf(_L("\tSending State: %d\n"), aEntry.SendingState());

	if (header->Type() == CSmsPDU::ESmsDeliver)

		{

 		CSmsDeliver& pdu = header->Deliver();

		TBool found = EFalse;

		TInt destination, originator, is16Bit;

		destination = originator = is16Bit = 0;

		if (pdu.UserDataPresent())

			{

			const CSmsUserData& userData = pdu.UserData();

			TInt count = userData.NumInformationElements();

			iRTest.Printf(_L("\tPdu contains %d information elements\n"), count);

			while (!found && count--)

				{

				CSmsInformationElement& nextIE=userData.InformationElement(count);

				switch(nextIE.Identifier())

					{

					case CSmsInformationElement::ESmsIEIApplicationPortAddressing8Bit:

					case CSmsInformationElement::ESmsIEIApplicationPortAddressing16Bit:

						{

						pdu.ApplicationPortAddressing(destination, originator, &is16Bit);

						found = ETrue;

						break;

						}

					default:

						break;

					}

				}

			}

		if (found)

			iRTest.Printf(_L("\tApplication Port Addressing: Dest %d, Origin %d, is16Bit %d\n"), destination, originator, is16Bit);

		else

			iRTest.Printf(_L("\tApplication Port Addressing: Not Found\n"));

		}

	CleanupStack::PopAndDestroy(header);

	CleanupStack::PopAndDestroy(cEntry);