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

// Utility functions for Sms Stack test harnesses

// 

//

/**

 @file

*/

#include <commsdattypesv1_1.h>

#include <logcli.h>

#include "smsstacktestutilities.h"

#include <e32math.h>

#include "smsustrm.h"

#include "Gsmumsg.h"

#include "smsuaddr.H"

#include "gsmubuf.h"

#include "smspdudb.h"

#include <e32test.h>

#include <f32file.h>

#include "SmsuTimer.h"

#include "smsstacklog.h"

#include <logwraplimits.h>

using namespace CommsDat;

// Check a boolean is true

#define LOCAL_CHECKPOINT(a) iTestStep->testBooleanTrue((a), (TText8*)__FILE__, __LINE__)

// Check a boolean is true if not return error code b

#define LOCAL_CHECKPOINT_CODE(a, b) iTestStep->testBooleanTrueWithErrorCode((a), (b), (TText8*)__FILE__, __LINE__)

#define LOCAL_CHECKPOINT_COMPAREL(p1, p2, p3) iTestStep->TestCheckPointCompareL((p1), (p2), (p3), (TText8*)__FILE__, __LINE__)

// TestExecute style Printf

#define PRINTF1(p1)							iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1))

#define PRINTF2(p1, p2)						iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2))

#define PRINTF3(p1, p2, p3)					iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3))

#define PRINTF4(p1, p2, p3, p4)				iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4))

#define PRINTF5(p1, p2, p3, p4, p5)			iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5))

#define PRINTF6(p1, p2, p3, p4, p5, p6)		iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6))

#define PRINTF7(p1, p2, p3, p4, p5, p6, p7)	iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7))

class CTSmsRegTstActive : public CActive

	{

public:

	CTSmsRegTstActive();

	~CTSmsRegTstActive();

	void StartL();

protected:

	void DoCancel();

	void RunL();

	};

CTSmsRegTstActive::CTSmsRegTstActive():

	CActive(0)

	{

	CActiveScheduler::Add(this);

	}

CTSmsRegTstActive::~CTSmsRegTstActive()

	{

	Cancel();

	}

void CTSmsRegTstActive::DoCancel()

	{

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrNone);

	}

void CTSmsRegTstActive::StartL()

	{

	SetActive();

	}

void CTSmsRegTstActive::RunL()

	{

	CActiveScheduler::Stop();

	}

EXPORT_C CSmsStackTestUtils* CSmsStackTestUtils::NewL(CTestStep* aTestStep, RFs& aFs)

	{

	CSmsStackTestUtils* self = new (ELeave) CSmsStackTestUtils(aTestStep, aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CSmsStackTestUtils::ConstructL()

	{

	iCharConv = CCnvCharacterSetConverter::NewL();

	}

EXPORT_C CSmsStackTestUtils::~CSmsStackTestUtils()

	{

	delete iCharConv;

	}

CSmsStackTestUtils::CSmsStackTestUtils(CTestStep* aTestStep, RFs& aFs)

: iTestStep(aTestStep), iFs(aFs)

	{

	}

EXPORT_C void CSmsStackTestUtils::WaitForInitializeL()

/**

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

 */

	{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	TName tsy;

	TUint32 modemId = 0;

	CMDBField<TUint32>* globalSettingsField = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);

	CleanupStack::PushL(globalSettingsField);

	globalSettingsField->SetRecordId(1);

	globalSettingsField->LoadL(*db);

	modemId = *globalSettingsField;

	CleanupStack::PopAndDestroy(globalSettingsField);

	CMDBField<TDesC>* tsyField = new(ELeave) CMDBField<TDesC>(KCDTIdTsyName);

	CleanupStack::PushL(tsyField);

	tsyField->SetRecordId(modemId);

	tsyField->SetMaxLengthL(KMaxTextLength);

	tsyField->LoadL(*db);

	tsy = *tsyField;

	CleanupStack::PopAndDestroy(tsyField);

	CleanupStack::PopAndDestroy(db);

	PRINTF2(_L("Loading TSY \"%S\"..."), &tsy);

	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;

	TBool found=EFalse;

	while (numPhones--)

		{

		TName phoneTsy;

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

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

			{

			PRINTF1(_L("Found RPhone..."));

			found = ETrue;

			RTelServer::TPhoneInfo info;

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

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

			CleanupClosePushL(phone);

			PRINTF1(_L("Initializing..."));

			const TInt err = phone.Initialise();

			TTimeIntervalMicroSeconds32 InitPause=9000000;  //Required Pause to Allow SMSStack to Complete its Async Init

			User::After(InitPause);							//call to the TSY and finish its StartUp.

			PRINTF2(_L("Completed Initialize [err=%d]"), err);

			User::LeaveIfError(err);

			CleanupStack::PopAndDestroy(&phone);

			break;

			}

		}

	LOCAL_CHECKPOINT(found);

	CleanupStack::PopAndDestroy(&server);

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketLC(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddrFamily aFamily)

/**

 *  Initialise an RSocket for SMS

 *  @note aSocket is pushed to CleanupStack.

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aFamily The sms address family

 */

	{

	OpenSmsSocketL(aSocketServer, aSocket, aFamily);

	CleanupClosePushL(aSocket);

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketL(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddrFamily aFamily)

/**

 *  Initialise an RSocket for SMS, aSocket is NOT pushed to CleanupStack.

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aFamily The sms address family

 */

	{

	TSmsAddr smsaddr;

	smsaddr.SetSmsAddrFamily(aFamily);

	OpenSmsSocketL(aSocketServer, aSocket, smsaddr);

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketLC(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddr& aSmsAddr)

/**

 *  Initialise an RSocket for SMS.

 *  @note aSocket is pushed to CleanupStack

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aSmsAddr The sms address to bind to

 */

	{

	OpenSmsSocketL(aSocketServer, aSocket, aSmsAddr);

	CleanupClosePushL(aSocket);

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketL(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddr& aSmsAddr)

/**

 *  Initialise an RSocket for SMS, aSocket is NOT pushed to CleanupStack.

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aSmsAddr The sms address to bind to

 */

	{

	TInt ret=aSocket.Open(aSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);

	PRINTF2(_L("Socket Open Return Value : %d"),ret);

	LOCAL_CHECKPOINT(ret == KErrNone);

	CleanupClosePushL(aSocket);

	ret=aSocket.Bind(aSmsAddr);

	PRINTF2(_L("Socket Bind Return Value : %d"),ret);

	LOCAL_CHECKPOINT(ret == KErrNone);

	WaitForInitializeL();

	CleanupStack::Pop(&aSocket);

	}

EXPORT_C void CSmsStackTestUtils::SendSmsAndChangeBearerL(CSmsMessage* aSms, RSocket& aSocket, RMobileSmsMessaging::TMobileSmsBearer aBearer)

/**

 *  Stream aSms out to the socket server. The idea is to change bearer midway through

 *  sending the PDUs making up the complete message.

 *  @param aSms contains the sms tpdu that will be streamed to the sms stack

 *  @param aSocket is used to stream the aSms to the sms stack

 *  @param aBearer Bearer setting that is changed to CommDb

 *  @leave Leaves if streaming the message to the socket server doesn't succeed

 *  @leave Leaves if sending is completed with error code

 */

	{

	RSmsSocketWriteStream writestream(aSocket);

	TRAPD(ret,writestream << *aSms);

	LOCAL_CHECKPOINT(ret == KErrNone);

	TRAP(ret,writestream.CommitL());

	LOCAL_CHECKPOINT(ret == KErrNone);

    // Create comms database object

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

	CleanupStack::PushL(db);

 	//Send message and change bearer

	TPckgBuf<TUint> sbuf;

	TRequestStatus status;

	aSocket.Ioctl(KIoctlSendSmsMessage,status,&sbuf, KSolSmsProv);

	//Wait couple of seconds to ensure first pdus of message have been sent

	User::After(2500000);

	// Change bearer

	CMDBField<TUint32>* smsBearerField = new(ELeave) CMDBField<TUint32>(KCDTIdSMSBearer);

	CleanupStack::PushL(smsBearerField);

	smsBearerField->SetRecordId(1); //it's GlobalSettingsRecord

	*smsBearerField = aBearer;

	smsBearerField->ModifyL(*db);

	CleanupStack::PopAndDestroy(smsBearerField);

	CleanupStack::PopAndDestroy(db);

	User::WaitForRequest(status);

	PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"), status.Int());

	LOCAL_CHECKPOINT(status.Int() == KErrNone);

	CSmsBuffer& smsbuffer = (CSmsBuffer&)aSms->Buffer();

	TInt len = smsbuffer.Length();

	HBufC* hbuf = HBufC::NewL(len);

	TPtr ptr = hbuf->Des();

	smsbuffer.Extract(ptr,0,len);

	PRINTF2(_L("SMS contains %d characters"),len);

	delete hbuf;

	}

EXPORT_C void CSmsStackTestUtils::ChangeBearerL(RMobileSmsMessaging::TMobileSmsBearer aBearer)

/**

Change the bearer in CommDB global settings.

@param aBearer The new bearer setting.

@return none

*/

	{

	// Start a CommDB session

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	// Change bearer in global settings

	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

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

	if (err != KErrNone)

		{

		PRINTF2(_L("Could not load global settings. Error = %d\n"), err);

		User::Leave(err);

		}

	((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer = aBearer;

	globalSettingsRecord.ModifyL(*db);

	PRINTF2(_L("Setting bearer in global settings to %d\n"), aBearer); 

	CleanupStack::PopAndDestroy(db);

	}

EXPORT_C void CSmsStackTestUtils::GetBearerL(RMobileSmsMessaging::TMobileSmsBearer& aBearer)

/**

Get the bearer from CommDB global settings.

@param aBearer The bearer setting retrieved from global settings.

@return none

*/

	{

	// Start a CommDB session

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	// Load global settings

	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

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

	if (err != KErrNone)

		{

		PRINTF2(_L("Could not load global settings. Error = %d\n"), err);

		User::Leave(err);

		}

	TInt tempBearer = ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer;

	aBearer = static_cast<RMobileSmsMessaging::TMobileSmsBearer>(tempBearer);

	PRINTF2(_L("Got bearer from CommDB. Bearer = %d\n"), aBearer);

	CleanupStack::PopAndDestroy(db);

	}

EXPORT_C void CSmsStackTestUtils::DisableLogging()

 	{

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

 	CleanupStack::PushL(testActive);

 	testActive->StartL();	

 	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

 	CleanupStack::PushL(logWrapper);

 	CLogClient& logClient = static_cast<CLogClient&>(logWrapper->Log());

 	TLogConfig config;

 	logClient.GetConfig(config, testActive->iStatus);

 	CActiveScheduler::Start();

 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

 	// Disable logging

 	config.iMaxEventAge = 0;

 	config.iMaxLogSize = 0;

 	config.iMaxRecentLogSize = 0;

 	testActive->StartL();

 	logClient.ChangeConfig(config, testActive->iStatus);

 	CActiveScheduler::Start();

 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

 	CleanupStack::PopAndDestroy(logWrapper);	

 	CleanupStack::PopAndDestroy(testActive);

	}

 EXPORT_C void CSmsStackTestUtils::EnableLogging()

 	{

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

 	CleanupStack::PushL(testActive);

 	testActive->StartL();	

 	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

 	CleanupStack::PushL(logWrapper);

 	CLogClient& logClient = static_cast<CLogClient&> (logWrapper->Log());

 	TLogConfig config;

 	logClient.GetConfig(config, testActive->iStatus);

 	CActiveScheduler::Start();

 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

 	// Enable logging

 	config.iMaxEventAge = 10000;

 	config.iMaxLogSize  = 10000; 

 	config.iMaxRecentLogSize = 127; 

 	testActive->StartL();	

 	logClient.ChangeConfig(config, testActive->iStatus);

 	CActiveScheduler::Start();

 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

 	CleanupStack::PopAndDestroy(logWrapper);	

 	CleanupStack::PopAndDestroy(testActive);

 }		

EXPORT_C void CSmsStackTestUtils::GetLogEventL(CLogEvent& aLogEvent, TInt aLogServerId)

/**

 *  Get SMS log event from event logger.

 *  @param aLogEvent reference to the CLogEvent object

 *  @param aLogServerId number of log event

 */

	{

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

	CleanupStack::PushL(testActive);

	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

	CleanupStack::PushL(logWrapper);

	aLogEvent.SetId(aLogServerId);

	testActive->StartL();

	logWrapper->Log().GetEvent(aLogEvent,testActive->iStatus);

	CActiveScheduler::Start();

	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

	CleanupStack::PopAndDestroy(2);	// testActive, logWrapper

	}

EXPORT_C TLogId CSmsStackTestUtils::AddLogEventL(CSmsMessage& aSmsMessage,TLogSmsPduData& aSmsPDUData)

/**

 *  Add SMS log event to the event logger.

 *  @param aSmsMessage SM mesage

 *  @param aLogSmsPduData initialised structure  with data relevant to logging

 */

	{

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

	CleanupStack::PushL(testActive);

	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

	CleanupStack::PushL(logWrapper);

	TLogId id=NULL;

	if(logWrapper->ClientAvailable())

	{

		testActive->StartL();

		CLogEvent* logevent=CLogEvent::NewL();

		CleanupStack::PushL(logevent);

		TBuf<KLogMaxDirectionLength> direction;

		User::LeaveIfError(logWrapper->Log().GetString(direction,R_LOG_DIR_OUT));

		logevent->SetDirection(direction);

		logevent->SetEventType(KLogShortMessageEventTypeUid);

		logevent->SetNumber(aSmsMessage.ToFromAddress());

		logevent->SetSubject(_L("test"));

		logevent->SetStatus(_L("status"));

		TPckg<TLogSmsPduData> packeddata(aSmsPDUData);

		logevent->SetDataL(packeddata);

		logWrapper->Log().AddEvent(*logevent,testActive->iStatus);

		CActiveScheduler::Start();

		LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

		id=logevent->Id();

		CleanupStack::PopAndDestroy(logevent);

	}

	CleanupStack::PopAndDestroy(2);	// testActive, logWrapper

	return id;

	}

EXPORT_C void CSmsStackTestUtils::CopyConfigFileL(const TDesC& aFromSmsConfigFile, CSmsPduDatabase* aPduDb)

	{

	PRINTF3(_L("Copying %S to %S..."), &aFromSmsConfigFile, &KSimTsyConfigFileName);

	TBool createdDb = EFalse;

	if (aPduDb == NULL)

		{

		aPduDb = CSmsPduDatabase::NewL(iFs);

		CleanupStack::PushL(aPduDb);

		createdDb = ETrue;

		}

	aPduDb->RewriteFileL(aFromSmsConfigFile, KGmsSmsConfigFileDir, KSimTsyConfigFileName);

	PRINTF1(_L("done"));

	if (createdDb)

		CleanupStack::PopAndDestroy(aPduDb);

	}

EXPORT_C CSmsMessage* CSmsStackTestUtils::CreateSmsMessageLC(CSmsPDU::TSmsPDUType aType, const TDesC& aDestination, const TDesC& aMessage)

	{

	CSmsBuffer* buffer = CSmsBuffer::NewL();

	buffer->InsertL(0, aMessage);

	CSmsMessage* message = CSmsMessage::NewL(iFs, aType, buffer);

	CleanupStack::PushL(message);

	message->SetToFromAddressL(aDestination);

	return message;

	}

EXPORT_C void CSmsStackTestUtils::AddSmsRxL(CTestConfig& aConfigFile, TInt aTestNumber, CSmsMessage& aMessage, const TDesC& aServiceCenter) const

	{