// 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 "t_smcmrecvmanual.h"

#include <msvuids.h>

#include <smuthdr.h>

#include <smscmds.h>

#include <msgtestscripts.h>

#include <txtrich.h>

_LIT(KSmcmRecvOnlyTestName, "Receive SMS Messages");

_LIT(KHelpText, "\n[1] Start Watchers\n[2] Stop Watchers\n[3] Send myself message\n[D] Display Unmatched Messages\ne[X]it\n");

_LIT(KMessageText, "\n[1] Short Message\n[2] Long Message\n[3] Message Indication\n[4] Replace Type\n[5] From sendrecv.script\n[D] Display Unmatched Messages\ne[X]it\n");

_LIT(KSmsScript, "sendrecv.script");

_LIT(KDefaultScript, "defaults.script");

_LIT(KRecipients, "Recipients");

_LIT(KServiceCenter, "SC");

const TInt KWaitAfterRecv = 100000; //< 0.1 second

RTest test(_L("T_SmcmRecvManual: Receive SMS Messages"));

CTrapCleanup* theCleanup;

LOCAL_C void doMainL()

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install( scheduler );

	CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test);

	CleanupStack::PushL(smsTest);

	TInt nextTest = 0;

	smsTest->NotifySaPhoneOnL();

	CSmcmRecvOnly* scTest = CSmcmRecvOnly::NewLC(*smsTest, KSmsScript, nextTest);

	scTest->StartL();

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(3); //SmsTest, scheduler

	}

GLDEF_C TInt E32Main()

	{	

	__UHEAP_MARK;

	test.Start(_L("Setup"));

	theCleanup = CTrapCleanup::New();

	TRAPD(ret,doMainL());		

	test(ret==KErrNone);

	delete theCleanup;	

	test.Console()->SetPos(0, 13);

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return(KErrNone);

	}

CSmcmRecvOnly::~CSmcmRecvOnly()

/**

 * CSmcmRecvOnly destructor

 */

	{

	Cancel();

	delete iRecvActive;

	delete iWatchers;

	delete iOperation;

	iOperation = NULL;

	delete iRecipient;

	delete iServiceCenter;

	delete iSelection;

	iSelection = NULL;

	}

CSmcmRecvOnly* CSmcmRecvOnly::NewLC(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)

/**

 * CSmcmRecvOnly factory function

 */

	{

	CSmcmRecvOnly* self = new (ELeave) CSmcmRecvOnly(aSmsTest, aScriptFile, aNextTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CSmcmRecvOnly::CSmcmRecvOnly(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)

: CSmsTestBase(aSmsTest, aScriptFile, aNextTest)

/**

 * CSmcmRecvOnly constructor

 */

	{

	CActiveScheduler::Add(this);

	}

void CSmcmRecvOnly::DisplayAndRead(const TDesC& aText)

/**

 * Displays aText then issues a read on the console

 */

	{

	iSmsTest.Printf(aText);

	Read();

	}

void CSmcmRecvOnly::RunAutoL()

	{

	DisplayAndRead(KHelpText);

	}

void CSmcmRecvOnly::ConstructL()

	{

	iSmsTest.NotifySaPhoneOnL();

	SetTestNameL(KSmcmRecvOnlyTestName);

	iSmsTest.InstantiateClientMtmsL();

	iSmsTest.SetLogToFile();

	iRecvActive = CSmcmRecvActive::NewL(iSmsTest, Priority()-1);

	iSelection = new (ELeave) CMsvEntrySelection;

	User::After(1000000);

	CScriptFile* script = CScriptFile::NewLC(iSmsTest, KSmsComponent);

	script->ReadScriptL(KDefaultScript);

	iRecipient = script->ItemValue(KDefaults, KRecipients, KNullDesC).AllocL();

	iServiceCenter = script->ItemValue(KDefaults, KServiceCenter, KNullDesC).AllocL();

	CleanupStack::PopAndDestroy(script);

	User::After(1000000);

	iSmsTest.Printf(_L("Deleting SMS messages in outbox..."));

	iSmsTest.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId);

	User::After(1000000);

	iSmsTest.Printf(_L("Done\nDeleting SMS messages in sent..."));

	iSmsTest.DeleteSmsMessagesL(KMsvSentEntryId);

	User::After(1000000);

	iSmsTest.Printf(_L("Done\nDeleting SMS messages in inbox..."));

	iSmsTest.DeleteSmsMessagesL(KMsvGlobalInBoxIndexEntryId);

	iSmsTest.Printf(_L("Done\n"));

	}

void CSmcmRecvOnly::ShowMenuL()

	{

	RunAutoL();

	}

void CSmcmRecvOnly::DoRunMainMenuL(TKeyCode aCode)

/**

 * Called by RunL when iState == EMainMenu, when there is a key press event.

 * Acts on the user's request.

 */

	{

	const TChar ch = TChar(aCode);

	const TDesC* text = &KHelpText();

	switch (ch)

		{

		case '1':

			iSmsTest.Printf(_L("\nStarting Watchers\n"));

			if (iWatchers == NULL)

				iWatchers = CTestUtilsWatcherStarter::NewL(Priority());

			else

				iSmsTest.Printf(_L("OOPS: Watchers already started!!\n"));

			break;

		case '2':

			iSmsTest.Printf(_L("\nStopping Watchers\n"));

			if (iWatchers == NULL)

				iSmsTest.Printf(_L("OOPS: Watchers not started yet!!\n"));

			else

				{

				delete iWatchers;

				iWatchers = NULL;

				}

			break;

		case '3':

			text = &KMessageText();

			iState = ESendingMenu;

			break;

		case 'D':

		case 'd':

			iRecvActive->DisplayUnmatched();

			break;

		case 'x':

		case 'X':

		case EKeyEscape:

			text = NULL;

			Complete(KErrNone);

			break;

		case EKeySpace:

			ReshowMenu();

			break;

		default:

			Read();

			break;

		}

	if (!IsActive() && text != NULL)

		DisplayAndRead(*text);

	}

void CSmcmRecvOnly::Read()

/**

 * Issues an asynchronous read on the console

 */

	{

	Cancel();

	iSmsTest.Test().Console()->Read(iStatus);

	SetActive();

	}

void CSmcmRecvOnly::SendReplaceTypeL()

	{

	iSmsTest.Printf(_L("\nSendReplaceTypeL\n"));

	_LIT(KShortMessage, "Replace Type %d");

	TBuf<64> buf;

	buf.AppendFormat(KShortMessage, iReplaceTypeCount++);

	const TMsvId id = CreateMessageLC(buf);

	CSmsHeader* header = iSmsTest.GetHeaderLC(id);

	CSmsSubmit& submit = header->Submit();

	submit.SetPIDType(TSmsProtocolIdentifier::ESmsPIDShortMessageType);

	submit.SetShortMessageType(TSmsProtocolIdentifier::ESmsReplaceShortMessageType1);

	StoreMessageL(id, *header);

	CleanupStack::PopAndDestroy(header);

	iSelection->Reset();

	iSelection->AppendL(id);

	ScheduleSendL();

	iSmsTest.iMsvSession->CleanupEntryPop(); //id

	}

void CSmcmRecvOnly::DoRunSendingMenuL(TKeyCode aCode)

/**

 * Called by RunL when iState == ESendingMenu, when there is a key press event.

 * Acts on the user's sending request.

 */

	{

	const TChar ch = TChar(aCode);

	switch (ch)

		{

		case '1':

			SendShortMessageL();

			break;

		case '2':

			SendLongMessageL();

			break;

		case '3':

			SendMessageIndicationL();

			break;

		case '4':

			SendReplaceTypeL();

			break;

		case '5':

			SendFromScriptL();

			break;

		case 'D':

		case 'd':

			iRecvActive->DisplayUnmatched();

			ReshowMenu();

			break;

		case 'x':

		case 'X':

		case EKeyEscape:

			DisplayAndRead(KHelpText);

			iState = EMainMenu;

			break;

		case EKeySpace:

			ReshowMenu();

			break;

		default:

			Read();

			break;

		}

	}

void CSmcmRecvOnly::ReshowMenu()

/**

 * Redisplays the current menu

 */

	{

	const TDesC* menu = NULL;

	switch (iState)

		{

		case EMainMenu:

			menu = &KHelpText();

			break;

		case ESendingMenu:

			menu = &KMessageText();

			break;

		default:

			break;

		}

	if (menu != NULL)

		{

		DisplayAndRead(*menu);

		}

	}

void CSmcmRecvOnly::SendFromScriptL()

/**

 * Sends SMS messages from sendrecv.script

 */

	{

	iSmsTest.Printf(_L("\nSendFromScriptL\n"));

	iSelection->Reset();

	TTime now;

	now.HomeTime();

	iSmsTest.ReadScriptL(iScriptFile, KMsvGlobalOutBoxIndexEntryId, *iSelection, now);

	ScheduleSendL();

	}

void CSmcmRecvOnly::SendLongMessageL()

/**

 * Sends a 2-part concatenated SMS message

 */

	{

	iSmsTest.Printf(_L("\nSendLongMessageL\n"));

	_LIT(KLongMessage, "LungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungoLungo");

	const TMsvId id = CreateMessageLC(KLongMessage);

	iSelection->Reset();

	iSelection->AppendL(id);

	ScheduleSendL();

	iSmsTest.iMsvSession->CleanupEntryPop(); //id

	}

TMsvId CSmcmRecvOnly::CreateMessageLC(const TDesC& aBody)

/**

 * Creates a message in the outbox with body text aBody

 *

 * @param aBody Body text of the new message

 * @return ID of the new message

 */

	{

	const TMsvId id = iSmsTest.CreateDummyMessageToSendL();

	iSmsTest.iMsvSession->CleanupEntryPushL(id);

	CSmsHeader* header = iSmsTest.GetHeaderLC(id);

	header->Recipients().ResetAndDestroy();

	CSmsNumber* number = CSmsNumber::NewL();

	CleanupStack::PushL(number);

	number->SetAddressL(*iRecipient);

	number->SetNameL(*iRecipient);

	header->Recipients().AppendL(number);

	CleanupStack::Pop(number);

	header->Submit().SetServiceCenterAddressL(*iServiceCenter);

	TMsvEntry entry(iSmsTest.Entry());

	entry.iDate.HomeTime();

	iSmsTest.ChangeEntryL(entry);

	_LIT(KDateFormat, " %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B %D%M%Y%/0%1%/1%2%/2%3%/3");

	TBuf<64> dateString;

	entry.iDate.FormatL(dateString, KDateFormat);

	iSmsTest.iRichText->Reset();

	iSmsTest.iRichText->InsertL(0, dateString);

	iSmsTest.iRichText->InsertL(0, aBody);

	StoreMessageL(id, *header);

	CleanupStack::PopAndDestroy(header);

	return id;

	}

void CSmcmRecvOnly::SendShortMessageL()

/**

 * Sends a single-part SMS message

 */

	{

	iSmsTest.Printf(_L("\nSendShortMessageL\n"));

	_LIT(KShortMessage, "ridere");

	const TMsvId id = CreateMessageLC(KShortMessage);

	iSelection->Reset();

	iSelection->AppendL(id);

	ScheduleSendL();

	iSmsTest.iMsvSession->CleanupEntryPop(); //id

	}

void CSmcmRecvOnly::StoreMessageL(TMsvId aId, const CSmsHeader& aHeader)

/**

 * Stores the header against a message

 *

 * @param aId ID of the message

 * @param aHeader The CSmsHeader to store against the message

 */

	{

	iSmsTest.SetEntryL(aId);

	CMsvStore* store = iSmsTest.EditStoreL();

	CleanupStack::PushL(store);

	aHeader.StoreL(*store);

	store->StoreBodyTextL(*iSmsTest.iRichText);

	store->CommitL();

	CleanupStack::PopAndDestroy(store);

	}

void CSmcmRecvOnly::ScheduleSendL()

/**

 * Sends all messages in iSelection

 * @note Messages are actually scheduled. Actual ending occurs a few seconds later.

 */

	{

	iState = ESending;

	delete iOperation;

	iOperation = NULL;

	iOperation = iSmsTest.iMsvSession->TransferCommandL(*iSelection, ESmsMtmCommandScheduleCopy, KNullDesC8, iStatus);

	SetActive();

	}

void CSmcmRecvOnly::SendMessageIndicationL(TUint8 aMessageType, TUint8 aMessageCount)

/**

 * Sends an SMS message with Special SMS Message Indication set in the user data header.

 *

 * @param aMessageType The type of the Special SMS Message Indication

 * @param aMessageCount The number of "messages" waiting

 */

	{

	iSmsTest.Printf(_L("\nSendMessageIndicationL\n"));

	_LIT(KShortMessage, "SMI");

	const TMsvId id = CreateMessageLC(KShortMessage);

	CSmsHeader* header = iSmsTest.GetHeaderLC(id);

	TBuf8<2> data;

	data.SetLength(2);

	data[0] = aMessageType;

	data[1] = aMessageCount;

	header->Submit().UserData().AddInformationElementL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication, data);

	StoreMessageL(id, *header);

	CleanupStack::PopAndDestroy(header);

	iSelection->Reset();

	iSelection->AppendL(id);

	ScheduleSendL();

	iSmsTest.iMsvSession->CleanupEntryPop(); //id

	}

void CSmcmRecvOnly::DoRunSendingL()

/**

 * Called by CSmcmRecvOnly::RunL() when sending has completed.

 * Displays the current state of all sent messages (in iSelection) and determines whether there was and error.

 */

	{

	iSmsTest.SetProgressL(*iOperation);

	delete iOperation;

	iOperation = NULL;

	iSmsTest.Printf(_L("\nDoRunSendingL [iStatus=%d Progress.iError=%d]\n"), iStatus.Int(), iSmsTest.iProgress.iError);

	iSmsTest.DisplaySendingStatesL(*iSelection);

	TInt error = KErrNone;

	const TBool sendingComplete = iSmsTest.SendingCompleteL(*iSelection, error);

	iSmsTest.Printf(_L("[sendingCompete=%d error=%d]\n"), sendingComplete, error);

	if (iStatus.Int() == KErrNone && iSmsTest.iProgress.iError == KErrNone && error == KErrNone)

		iRecvActive->SentL(*iSelection);

	iState = ESendingMenu;

	DisplayAndRead(KMessageText);

	}

void CSmcmRecvOnly::RunL()

	{

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

	const TKeyCode keyCode = iSmsTest.Test().Console()->KeyCode();

	switch (iState)

		{

		case EMainMenu:

			DoRunMainMenuL(keyCode);